freeRTOS源码解析4--tasks.c 3

  1 void vTaskDelete( TaskHandle_t xTaskToDelete )
  2 {
  3     TCB_t * pxTCB;
  4     BaseType_t xDeleteTCBInIdleTask = pdFALSE;
  5     BaseType_t xTaskIsRunningOrYielding;
  6 
  7     taskENTER_CRITICAL();
  8     {
  9         /* If null is passed in here then it is the calling task that is
 10          * being deleted. */
 11         /* 如果是NULL就是删除自己，否则是删除其他任务 */
 12         pxTCB = prvGetTCBFromHandle( xTaskToDelete );
 13 
 14         /* Remove task from the ready/delayed list. */
 15         if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )
 16         {
 17             taskRESET_READY_PRIORITY( pxTCB->uxPriority );
 18         }
 19         else
 20         {
 21             mtCOVERAGE_TEST_MARKER();
 22         }
 23 
 24         /* Is the task waiting on an event also? */
 25         if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )
 26         {
 27             ( void ) uxListRemove( &( pxTCB->xEventListItem ) );
 28         }
 29         else
 30         {
 31             mtCOVERAGE_TEST_MARKER();
 32         }
 33 
 34         /* Increment the uxTaskNumber also so kernel aware debuggers can
 35          * detect that the task lists need re-generating.  This is done before
 36          * portPRE_TASK_DELETE_HOOK() as in the Windows port that macro will
 37          * not return. */
 38         /* 这个变量是用于TRACE相关的，调试用的，先不管，以后看trace的代码再解析 */
 39         uxTaskNumber++;
 40 
 41         /* Use temp variable as distinct sequence points for reading volatile
 42          * variables prior to a logical operator to ensure compliance with
 43          * MISRA C 2012 Rule 13.5. */
 44         /* 确定是否正在运行或正在调度到这个任务 */
 45         xTaskIsRunningOrYielding = taskTASK_IS_RUNNING_OR_SCHEDULED_TO_YIELD( pxTCB );
 46 
 47         /* If the task is running (or yielding), we must add it to the
 48          * termination list so that an idle task can delete it when it is
 49          * no longer running. */
 50         if( ( xSchedulerRunning != pdFALSE ) && ( xTaskIsRunningOrYielding != pdFALSE ) )
 51         {
 52             /* A running task or a task which is scheduled to yield is being
 53              * deleted. This cannot complete when the task is still running
 54              * on a core, as a context switch to another task is required.
 55              * Place the task in the termination list. The idle task will check
 56              * the termination list and free up any memory allocated by the
 57              * scheduler for the TCB and stack of the deleted task. */
 58             /* 看注释，不放到终止列表中，无法删除。需要依赖空闲任务来处理
 59              * 具体原因暂时还不清楚，看来需要阅读更多源码才能明白。 */
 60             vListInsertEnd( &xTasksWaitingTermination, &( pxTCB->xStateListItem ) );
 61 
 62             /* Increment the ucTasksDeleted variable so the idle task knows
 63              * there is a task that has been deleted and that it should therefore
 64              * check the xTasksWaitingTermination list. */
 65             ++uxDeletedTasksWaitingCleanUp;
 66 
 67             /* Delete the task TCB in idle task. */
 68             xDeleteTCBInIdleTask = pdTRUE;
 69 
 70             /* The pre-delete hook is primarily for the Windows simulator,
 71              * in which Windows specific clean up operations are performed,
 72              * after which it is not possible to yield away from this task -
 73              * hence xYieldPending is used to latch that a context switch is
 74              * required. */
 75             /* 只有在Windows下才有用，先不分析了 */
 76             #if ( configNUMBER_OF_CORES == 1 )
 77                 portPRE_TASK_DELETE_HOOK( pxTCB, &( xYieldPendings[ 0 ] ) );
 78             #endif
 79         }
 80         else
 81         {
 82             /* 这里是删除阻塞任务(pxDelayedTaskList)的(xTaskIsRunningOrYielding = pdFALSE) */
 83             --uxCurrentNumberOfTasks;
 84 
 85             /* Reset the next expected unblock time in case it referred to
 86              * the task that has just been deleted. */
 87             /* 主要用于更新最久阻塞的剩余阻塞时间，防止最近需要运行的就是删除的这个任务 */
 88             prvResetNextTaskUnblockTime();
 89         }
 90     }
 91     taskEXIT_CRITICAL();
 92 
 93     /* If the task is not deleting itself, call prvDeleteTCB from outside of
 94      * critical section. If a task deletes itself, prvDeleteTCB is called
 95      * from prvCheckTasksWaitingTermination which is called from Idle task. */
 96     /* 如果删除的是当前运行的任务在空闲任务中处理，阻塞任务在这里处理 */
 97     if( xDeleteTCBInIdleTask != pdTRUE )
 98     {
 99         prvDeleteTCB( pxTCB );
100     }
101 
102     /* Force a reschedule if it is the currently running task that has just
103      * been deleted. */
104     /* 如果删除的是当前运行的任务，需要调度，这很明显。 */
105     #if ( configNUMBER_OF_CORES == 1 )
106     {
107         if( xSchedulerRunning != pdFALSE )
108         {
109             if( pxTCB == pxCurrentTCB )
110             {
111                 configASSERT( uxSchedulerSuspended == 0 );
112                 taskYIELD_WITHIN_API();
113             }
114             else
115             {
116                 mtCOVERAGE_TEST_MARKER();
117             }
118         }
119     }
120     #endif /* #if ( configNUMBER_OF_CORES == 1 ) */
121 }

 1 static void prvDeleteTCB( TCB_t * pxTCB )
 2 {
 3     #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) && ( portUSING_MPU_WRAPPERS == 0 ) )
 4     {
 5         /* The task can only have been allocated dynamically - free both
 6          * the stack and TCB. */
 7         vPortFreeStack( pxTCB->pxStack );
 8         vPortFree( pxTCB );
 9     }
10     #elif ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 )
11     {
12         /* The task could have been allocated statically or dynamically, so
13          * check what was statically allocated before trying to free the
14          * memory. */
15         /* 按需释放tcb和stack */
16         if( pxTCB->ucStaticallyAllocated == tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB )
17         {
18             /* Both the stack and TCB were allocated dynamically, so both
19              * must be freed. */
20             vPortFreeStack( pxTCB->pxStack );
21             vPortFree( pxTCB );
22         }
23         else if( pxTCB->ucStaticallyAllocated == tskSTATICALLY_ALLOCATED_STACK_ONLY )
24         {
25             /* Only the stack was statically allocated, so the TCB is the
26              * only memory that must be freed. */
27             vPortFree( pxTCB );
28         }
29         else
30         {
31             /* Neither the stack nor the TCB were allocated dynamically, so
32              * nothing needs to be freed. */
33             configASSERT( pxTCB->ucStaticallyAllocated == tskSTATICALLY_ALLOCATED_STACK_AND_TCB );
34             mtCOVERAGE_TEST_MARKER();
35         }
36     }
37     #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
38 }

  1 eTaskState eTaskGetState( TaskHandle_t xTask )
  2 {
  3     eTaskState eReturn;
  4     List_t const * pxStateList;
  5     List_t const * pxEventList;
  6     List_t const * pxDelayedList;
  7     List_t const * pxOverflowedDelayedList;
  8     const TCB_t * const pxTCB = xTask;
  9 
 10     configASSERT( pxTCB );
 11 
 12     #if ( configNUMBER_OF_CORES == 1 )
 13         if( pxTCB == pxCurrentTCB )
 14         {
 15             /* The task calling this function is querying its own state. */
 16             /* 当前任务是查询的任务，则处于运行态 */
 17             eReturn = eRunning;
 18         }
 19         else
 20     #endif
 21     {
 22         taskENTER_CRITICAL();
 23         {
 24             pxStateList = listLIST_ITEM_CONTAINER( &( pxTCB->xStateListItem ) );
 25             pxEventList = listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) );
 26             pxDelayedList = pxDelayedTaskList;
 27             pxOverflowedDelayedList = pxOverflowDelayedTaskList;
 28         }
 29         taskEXIT_CRITICAL();
 30 
 31         if( pxEventList == &xPendingReadyList )
 32         {
 33             /* The task has been placed on the pending ready list, so its
 34              * state is eReady regardless of what list the task's state list
 35              * item is currently placed on. */
 36             /* 任务的事件项处于xPendingReadyList中就是就绪态
 37              * 说明xPendingReadyList里放的是任务的xEventListItem
 38              * 调度器挂起时，任务已ready，调度器运行后，
 39              * 会将xPendingReadyList中的任务移至就绪列表中 */
 40             eReturn = eReady;
 41         }
 42         else if( ( pxStateList == pxDelayedList ) || ( pxStateList == pxOverflowedDelayedList ) )
 43         {
 44             /* The task being queried is referenced from one of the Blocked
 45              * lists. */
 46             /* pxDelayedTaskList和pxOverflowDelayedTaskList放的是阻塞任务，xStateListItem */
 47             eReturn = eBlocked;
 48         }
 49 
 50         #if ( INCLUDE_vTaskSuspend == 1 )
 51         /* xSuspendedTaskList放的是挂起的任务，xStateListItem */
 52         else if( pxStateList == &xSuspendedTaskList )
 53         {
 54             /* The task being queried is referenced from the suspended
 55              * list.  Is it genuinely suspended or is it blocked
 56              * indefinitely? */
 57             /* xEventListItem不在任何列表里 */
 58             if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL )
 59             {
 60                 #if ( configUSE_TASK_NOTIFICATIONS == 1 )
 61                 {
 62                     BaseType_t x;
 63 
 64                     /* The task does not appear on the event list item of
 65                      * and of the RTOS objects, but could still be in the
 66                      * blocked state if it is waiting on its notification
 67                      * rather than waiting on an object.  If not, is
 68                      * suspended. */
 69                     /* 说明等通知不是把xEventListItem放到某个列表里，
 70                      * 而且等通知会把任务放到挂起的列表里 */
 71                     eReturn = eSuspended;
 72 
 73                     for( x = ( BaseType_t ) 0; x < ( BaseType_t ) configTASK_NOTIFICATION_ARRAY_ENTRIES; x++ )
 74                     {
 75                         if( pxTCB->ucNotifyState[ x ] == taskWAITING_NOTIFICATION )
 76                         {
 77                             eReturn = eBlocked;
 78                             break;
 79                         }
 80                     }
 81                 }
 82                 #else /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
 83                 {
 84                     eReturn = eSuspended;
 85                 }
 86                 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
 87             }
 88             else
 89             {
 90                 /* 如果xStateListItem在挂起列表里且xEventListItem处于某个列表里，则任务会阻塞 */
 91                 eReturn = eBlocked;
 92             }
 93         }
 94         #endif /* if ( INCLUDE_vTaskSuspend == 1 ) */
 95 
 96         #if ( INCLUDE_vTaskDelete == 1 )
 97             else if( ( pxStateList == &xTasksWaitingTermination ) || ( pxStateList == NULL ) )
 98             {
 99                 /* The task being queried is referenced from the deleted
100                  * tasks list, or it is not referenced from any lists at
101                  * all. */
102                 /* 等着被删除，这很明显 */
103                 eReturn = eDeleted;
104             }
105         #endif
106 
107         else
108         {
109             #if ( configNUMBER_OF_CORES == 1 )
110             {
111                 /* If the task is not in any other state, it must be in the
112                  * Ready (including pending ready) state. */
113                 /* 剩下的就只能是在就绪列表里(pxReadyTasksLists)
114                  * pxReadyTasksLists是个列表数组，通过排除法，可以
115                  * 免于进行遍历操作。 */
116                 eReturn = eReady;
117             }
118             #else /* #if ( configNUMBER_OF_CORES == 1 ) */
119             {
120                 if( taskTASK_IS_RUNNING( pxTCB ) == pdTRUE )
121                 {
122                     /* Is it actively running on a core? */
123                     eReturn = eRunning;
124                 }
125                 else
126                 {
127                     /* If the task is not in any other state, it must be in the
128                      * Ready (including pending ready) state. */
129                     eReturn = eReady;
130                 }
131             }
132             #endif /* #if ( configNUMBER_OF_CORES == 1 ) */
133         }
134     }
135 
136     /* 简单总结下：xStateListItem会在pxDelayedTaskList、pxOverflowDelayedTaskList、
137      * xSuspendedTaskList和xTasksWaitingTermination里
138      * xEventListItem会在xPendingReadyList里。
139      * 简单分析就是事件、通知来了任务就放到xPendingReadyList里，其他情况就在其他列表里
140      * 具体是不是这样，看后面的源码，会逐渐清晰 */
141 
142     return eReturn;
143 }

  1 void vTaskDelay( const TickType_t xTicksToDelay )
  2 {
  3     BaseType_t xAlreadyYielded = pdFALSE;
  4 
  5     /* A delay time of zero just forces a reschedule. */
  6     /* 如果延迟tick为0, 则表示强制执行调度 */
  7     if( xTicksToDelay > ( TickType_t ) 0U )
  8     {
  9         vTaskSuspendAll();    // 停止调度器
 10         {
 11             configASSERT( uxSchedulerSuspended == 1U );
 12 
 13             /* A task that is removed from the event list while the
 14              * scheduler is suspended will not get placed in the ready
 15              * list or removed from the blocked list until the scheduler
 16              * is resumed.
 17              *
 18              * This task cannot be in an event list as it is the currently
 19              * executing task. */
 20             /* 在调度器暂停时, 从事件列表中删除的任务将不会被放置在就绪列表中
 21              * 或从阻塞列表中删除, 直到调度器恢复。此任务不可能在事件列表中,
 22              * 因为它是当前正在执行的任务。 */
 23             prvAddCurrentTaskToDelayedList( xTicksToDelay, pdFALSE );
 24         }
 25         xAlreadyYielded = xTaskResumeAll();
 26     }
 27     else
 28     {
 29         mtCOVERAGE_TEST_MARKER();
 30     }
 31 
 32     /* Force a reschedule if xTaskResumeAll has not already done so, we may
 33      * have put ourselves to sleep. */
 34     /* xTaskResumeAll没有调度, 那在这里手动调度 */
 35     if( xAlreadyYielded == pdFALSE )
 36     {
 37         taskYIELD_WITHIN_API();
 38     }
 39     else
 40     {
 41         mtCOVERAGE_TEST_MARKER();
 42     }
 43 }
 44 
 45 void vTaskSuspendAll( void )
 46 {
 47     #if ( configNUMBER_OF_CORES == 1 )
 48     {
 49         /* A critical section is not required as the variable is of type
 50          * BaseType_t.  Please read Richard Barry's reply in the following link to a
 51          * post in the FreeRTOS support forum before reporting this as a bug! -
 52          * https://goo.gl/wu4acr */
 53 
 54         /* portSOFTWARE_BARRIER() is only implemented for emulated/simulated ports that
 55          * do not otherwise exhibit real time behaviour. */
 56         portSOFTWARE_BARRIER();
 57 
 58         /* The scheduler is suspended if uxSchedulerSuspended is non-zero.  An increment
 59          * is used to allow calls to vTaskSuspendAll() to nest. */
 60         /* uxSchedulerSuspended非0, 则调度器暂停, 加1是为了嵌套调用(中断也调用) */
 61         uxSchedulerSuspended = ( UBaseType_t ) ( uxSchedulerSuspended + 1U );
 62 
 63         /* Enforces ordering for ports and optimised compilers that may otherwise place
 64          * the above increment elsewhere. */
 65         portMEMORY_BARRIER();
 66     }
 67     #endif /* #if ( configNUMBER_OF_CORES == 1 ) */
 68 }
 69 
 70 static void prvAddCurrentTaskToDelayedList( TickType_t xTicksToWait,
 71                                             const BaseType_t xCanBlockIndefinitely )
 72 {
 73     TickType_t xTimeToWake;
 74     const TickType_t xConstTickCount = xTickCount;
 75     List_t * const pxDelayedList = pxDelayedTaskList;
 76     List_t * const pxOverflowDelayedList = pxOverflowDelayedTaskList;
 77 
 78     #if ( INCLUDE_xTaskAbortDelay == 1 )
 79     {
 80         /* About to enter a delayed list, so ensure the ucDelayAborted flag is
 81          * reset to pdFALSE so it can be detected as having been set to pdTRUE
 82          * when the task leaves the Blocked state. */
 83         pxCurrentTCB->ucDelayAborted = ( uint8_t ) pdFALSE;
 84     }
 85     #endif
 86 
 87     /* Remove the task from the ready list before adding it to the blocked list
 88      * as the same list item is used for both lists. */
 89     /* 将当前任务移出的列表必然是就绪列表, 移出后的就绪列表的item数量为0, 表示
 90      * 就绪列表为空了, 需要重置下uxTopReadyPriority */
 91     if( uxListRemove( &( pxCurrentTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )
 92     {
 93         /* The current task must be in a ready list, so there is no need to
 94          * check, and the port reset macro can be called directly. */
 95         portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority );
 96     }
 97     else
 98     {
 99         mtCOVERAGE_TEST_MARKER();
100     }
101 
102     #if ( INCLUDE_vTaskSuspend == 1 )
103     {
104         if( ( xTicksToWait == portMAX_DELAY ) && ( xCanBlockIndefinitely != pdFALSE ) )
105         {
106             /* Add the task to the suspended task list instead of a delayed task
107              * list to ensure it is not woken by a timing event.  It will block
108              * indefinitely. */
109             /* 无限等待, 就加入到挂起列表里 */
110             listINSERT_END( &xSuspendedTaskList, &( pxCurrentTCB->xStateListItem ) );
111         }
112         else
113         {
114             /* Calculate the time at which the task should be woken if the event
115              * does not occur.  This may overflow but this doesn't matter, the
116              * kernel will manage it correctly. */
117             /* 计算延迟结束的tick */
118             xTimeToWake = xConstTickCount + xTicksToWait;
119 
120             /* The list item will be inserted in wake time order. */
121             /* 说明xStateListItem的项里的值, 放的是wake的时间点 */
122             listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xStateListItem ), xTimeToWake );
123 
124             if( xTimeToWake < xConstTickCount )
125             {
126                 /* Wake time has overflowed.  Place this item in the overflow
127                  * list. */
128                 /* 处理数值溢出的情况, 说明wake的tick值溢出的话, 任务就在pxOverflowDelayedTaskList
129                  * 列表里, 这是freeRTOS处理tick溢出的方式, 即用两个delay列表交替使用来处理 */
130                 traceMOVED_TASK_TO_OVERFLOW_DELAYED_LIST();
131                 vListInsert( pxOverflowDelayedList, &( pxCurrentTCB->xStateListItem ) );
132             }
133             else
134             {
135                 /* The wake time has not overflowed, so the current block list
136                  * is used. */
137                 /* 没溢出就放到pxDelayedTaskList列表里, 一般一旦有溢出, 后面的任务
138                  * 都是处于溢出的情况, 一旦tick加到0了, 就会交换pxDelayedTaskList
139                  * 和pxOverflowDelayedTaskList指向的列表, 这样就解决了溢出的问题 */
140                 traceMOVED_TASK_TO_DELAYED_LIST();
141                 vListInsert( pxDelayedList, &( pxCurrentTCB->xStateListItem ) );
142 
143                 /* If the task entering the blocked state was placed at the
144                  * head of the list of blocked tasks then xNextTaskUnblockTime
145                  * needs to be updated too. */
146                 /* 更新最近唤醒任务的时间 */
147                 if( xTimeToWake < xNextTaskUnblockTime )
148                 {
149                     xNextTaskUnblockTime = xTimeToWake;
150                 }
151                 else
152                 {
153                     mtCOVERAGE_TEST_MARKER();
154                 }
155             }
156         }
157     }
158     #endif /* INCLUDE_vTaskSuspend */
159 }

 1 static void prvAddCurrentTaskToDelayedList( TickType_t xTicksToWait,
 2                                             const BaseType_t xCanBlockIndefinitely )
 3 {
 4     TickType_t xTimeToWake;
 5     const TickType_t xConstTickCount = xTickCount;
 6     List_t * const pxDelayedList = pxDelayedTaskList;
 7     List_t * const pxOverflowDelayedList = pxOverflowDelayedTaskList;
 8 
 9     #if ( INCLUDE_xTaskAbortDelay == 1 )
10     {
11         /* About to enter a delayed list, so ensure the ucDelayAborted flag is
12          * reset to pdFALSE so it can be detected as having been set to pdTRUE
13          * when the task leaves the Blocked state. */
14         pxCurrentTCB->ucDelayAborted = ( uint8_t ) pdFALSE;
15     }
16     #endif
17 
18     /* Remove the task from the ready list before adding it to the blocked list
19      * as the same list item is used for both lists. */
20     /* 将当前任务移出的列表必然是就绪列表, 移出后的就绪列表的item数量为0, 表示
21      * 就绪列表为空了, 需要重置下uxTopReadyPriority */
22     if( uxListRemove( &( pxCurrentTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )
23     {
24         /* The current task must be in a ready list, so there is no need to
25          * check, and the port reset macro can be called directly. */
26         portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority );
27     }
28     else
29     {
30         mtCOVERAGE_TEST_MARKER();
31     }
32 
33     #if ( INCLUDE_vTaskSuspend == 1 )
34     {
35         if( ( xTicksToWait == portMAX_DELAY ) && ( xCanBlockIndefinitely != pdFALSE ) )
36         {
37             /* Add the task to the suspended task list instead of a delayed task
38              * list to ensure it is not woken by a timing event.  It will block
39              * indefinitely. */
40             /* 无限等待, 就加入到挂起列表里 */
41             listINSERT_END( &xSuspendedTaskList, &( pxCurrentTCB->xStateListItem ) );
42         }
43         else
44         {
45             /* Calculate the time at which the task should be woken if the event
46              * does not occur.  This may overflow but this doesn't matter, the
47              * kernel will manage it correctly. */
48             /* 计算延迟结束的tick */
49             xTimeToWake = xConstTickCount + xTicksToWait;
50 
51             /* The list item will be inserted in wake time order. */
52             /* 说明xStateListItem的项里的值, 放的是wake的时间点 */
53             listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xStateListItem ), xTimeToWake );
54 
55             if( xTimeToWake < xConstTickCount )
56             {
57                 /* Wake time has overflowed.  Place this item in the overflow
58                  * list. */
59                 /* 处理数值溢出的情况, 说明wake的tick值溢出的话, 任务就在pxOverflowDelayedTaskList
60                  * 列表里, 这是freeRTOS处理tick溢出的方式, 即用两个delay列表交替使用来处理 */
61                 traceMOVED_TASK_TO_OVERFLOW_DELAYED_LIST();
62                 vListInsert( pxOverflowDelayedList, &( pxCurrentTCB->xStateListItem ) );
63             }
64             else
65             {
66                 /* The wake time has not overflowed, so the current block list
67                  * is used. */
68                 /* 没溢出就放到pxDelayedTaskList列表里, 一般一旦有溢出, 后面的任务
69                  * 都是处于溢出的情况, 一旦tick加到0了, 就会交换pxDelayedTaskList
70                  * 和pxOverflowDelayedTaskList指向的列表, 这样就解决了溢出的问题 */
71                 traceMOVED_TASK_TO_DELAYED_LIST();
72                 vListInsert( pxDelayedList, &( pxCurrentTCB->xStateListItem ) );
73 
74                 /* If the task entering the blocked state was placed at the
75                  * head of the list of blocked tasks then xNextTaskUnblockTime
76                  * needs to be updated too. */
77                 /* 更新最近唤醒任务的时间 */
78                 if( xTimeToWake < xNextTaskUnblockTime )
79                 {
80                     xNextTaskUnblockTime = xTimeToWake;
81                 }
82                 else
83                 {
84                     mtCOVERAGE_TEST_MARKER();
85                 }
86             }
87         }
88     }
89     #endif /* INCLUDE_vTaskSuspend */
90 }

 1 void vTaskSuspendAll( void )
 2 {
 3     #if ( configNUMBER_OF_CORES == 1 )
 4     {
 5         /* A critical section is not required as the variable is of type
 6          * BaseType_t.  Please read Richard Barry's reply in the following link to a
 7          * post in the FreeRTOS support forum before reporting this as a bug! -
 8          * https://goo.gl/wu4acr */
 9 
10         /* portSOFTWARE_BARRIER() is only implemented for emulated/simulated ports that
11          * do not otherwise exhibit real time behaviour. */
12         portSOFTWARE_BARRIER();
13 
14         /* The scheduler is suspended if uxSchedulerSuspended is non-zero.  An increment
15          * is used to allow calls to vTaskSuspendAll() to nest. */
16         /* uxSchedulerSuspended非0, 则调度器暂停, 加1是为了嵌套调用(中断也调用) */
17         uxSchedulerSuspended = ( UBaseType_t ) ( uxSchedulerSuspended + 1U );
18 
19         /* Enforces ordering for ports and optimised compilers that may otherwise place
20          * the above increment elsewhere. */
21         portMEMORY_BARRIER();
22     }
23     #endif /* #if ( configNUMBER_OF_CORES == 1 ) */
24 }

  1 BaseType_t xTaskResumeAll( void )
  2 {
  3     TCB_t * pxTCB = NULL;
  4     BaseType_t xAlreadyYielded = pdFALSE;
  5 
  6     {
  7         /* It is possible that an ISR caused a task to be removed from an event
  8          * list while the scheduler was suspended.  If this was the case then the
  9          * removed task will have been added to the xPendingReadyList.  Once the
 10          * scheduler has been resumed it is safe to move all the pending ready
 11          * tasks from this list into their appropriate ready list. */
 12         taskENTER_CRITICAL();
 13         {
 14             BaseType_t xCoreID;
 15             xCoreID = ( BaseType_t ) portGET_CORE_ID();    // 单核默认返回0
 16 
 17             /* If uxSchedulerSuspended is zero then this function does not match a
 18              * previous call to vTaskSuspendAll(). */
 19             /* vTaskSuspendAll和xTaskResumeAll成对调用, 所以前面必然是调用过了
 20              * vTaskSuspendAll, 那么uxSchedulerSuspended必然大于0的 */
 21             configASSERT( uxSchedulerSuspended != 0U );
 22 
 23             uxSchedulerSuspended = ( UBaseType_t ) ( uxSchedulerSuspended - 1U );
 24             portRELEASE_TASK_LOCK();
 25 
 26             if( uxSchedulerSuspended == ( UBaseType_t ) 0U )
 27             {
 28                 if( uxCurrentNumberOfTasks > ( UBaseType_t ) 0U )
 29                 {
 30                     /* Move any readied tasks from the pending list into the
 31                      * appropriate ready list. */
 32                     /* 为什么是xPendingReadyList, 因为调用vTaskSuspendAll后调度器暂停了,
 33                      * 如果在调用本接口前(本接口会进入临界区, 临界区会禁止所有系统中断)
 34                      * 有任务就绪了(中断、事件、通知等), 就会把任务放xPendingReadyList列表里 */
 35                     while( listLIST_IS_EMPTY( &xPendingReadyList ) == pdFALSE )
 36                     {
 37                         /* 把xPendingReadyList里的所有任务一个一个放到就绪列表中 */
 38                         pxTCB = listGET_OWNER_OF_HEAD_ENTRY( ( &xPendingReadyList ) );
 39                         listREMOVE_ITEM( &( pxTCB->xEventListItem ) );
 40                         portMEMORY_BARRIER();
 41                         listREMOVE_ITEM( &( pxTCB->xStateListItem ) );
 42                         prvAddTaskToReadyList( pxTCB );
 43 
 44                         #if ( configNUMBER_OF_CORES == 1 )
 45                         {
 46                             /* If the moved task has a priority higher than the current
 47                              * task then a yield must be performed. */
 48                             /* 如果取出来的任务有优先级比当前任务高的, 就需要调度, 先置标志位 */
 49                             if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )
 50                             {
 51                                 xYieldPendings[ xCoreID ] = pdTRUE;
 52                             }
 53                             else
 54                             {
 55                                 mtCOVERAGE_TEST_MARKER();
 56                             }
 57                         }
 58                         #endif /* #if ( configNUMBER_OF_CORES == 1 ) */
 59                     }
 60 
 61                     if( pxTCB != NULL )
 62                     {
 63                         /* A task was unblocked while the scheduler was suspended,
 64                          * which may have prevented the next unblock time from being
 65                          * re-calculated, in which case re-calculate it now.  Mainly
 66                          * important for low power tickless implementations, where
 67                          * this can prevent an unnecessary exit from low power
 68                          * state. */
 69                         /* 任务在调度器暂停时解除阻塞, 立即计算可以防止下一个解除阻塞
 70                          * 时间被重新计算, 这对于低功耗无障碍实现非常重要，因为这可以
 71                          * 防止不必要地退出低功耗 */
 72                         prvResetNextTaskUnblockTime();
 73                     }
 74 
 75                     /* If any ticks occurred while the scheduler was suspended then
 76                      * they should be processed now.  This ensures the tick count does
 77                      * not  slip, and that any delayed tasks are resumed at the correct
 78                      * time.
 79                      *
 80                      * It should be safe to call xTaskIncrementTick here from any core
 81                      * since we are in a critical section and xTaskIncrementTick itself
 82                      * protects itself within a critical section. Suspending the scheduler
 83                      * from any core causes xTaskIncrementTick to increment uxPendedCounts. */
 84                     /* 在调度器停止的时候, tick增加是增加xPendedTicks这个值, 在这里恢复调度器
 85                      * 的时候需要把这些增加的xPendedTicks值处理掉, 在临界区调用xTaskIncrementTick
 86                      * 是安全的, 至于为什么在解析xTaskIncrementTick后应该会清楚 */
 87                     {
 88                         TickType_t xPendedCounts = xPendedTicks; /* Non-volatile copy. */
 89 
 90                         if( xPendedCounts > ( TickType_t ) 0U )
 91                         {
 92                             do
 93                             {
 94                                 if( xTaskIncrementTick() != pdFALSE )
 95                                 {
 96                                     /* Other cores are interrupted from
 97                                      * within xTaskIncrementTick(). */
 98                                     xYieldPendings[ xCoreID ] = pdTRUE;
 99                                 }
100                                 else
101                                 {
102                                     mtCOVERAGE_TEST_MARKER();
103                                 }
104 
105                                 --xPendedCounts;
106                             } while( xPendedCounts > ( TickType_t ) 0U );
107 
108                             xPendedTicks = 0;
109                         }
110                         else
111                         {
112                             mtCOVERAGE_TEST_MARKER();
113                         }
114                     }
115 
116                     /* 需要调度的话, 这里立即开始调度(实际应该是
117                      * 等退出临界区后进入pendSV中断), 我暂时也不确定,
118                      * 等有空了仿真调式看看 */
119                     if( xYieldPendings[ xCoreID ] != pdFALSE )
120                     {
121                         #if ( configUSE_PREEMPTION != 0 )
122                         {
123                             xAlreadyYielded = pdTRUE;
124                         }
125                         #endif /* #if ( configUSE_PREEMPTION != 0 ) */
126 
127                         #if ( configNUMBER_OF_CORES == 1 )
128                         {
129                             taskYIELD_TASK_CORE_IF_USING_PREEMPTION( pxCurrentTCB );
130                         }
131                         #endif /* #if ( configNUMBER_OF_CORES == 1 ) */
132                     }
133                     else
134                     {
135                         mtCOVERAGE_TEST_MARKER();
136                     }
137                 }
138             }
139             else
140             {
141                 mtCOVERAGE_TEST_MARKER();
142             }
143         }
144         taskEXIT_CRITICAL();
145     }
146 
147     return xAlreadyYielded;
148 }