1 /* 根据FreeRTOSConfig.h配置的不同结构体会有差异, 这是我的结果 */
  2 struct xSTATIC_LIST_ITEM
  3 {
  4     TickType_t xDummy2;
  5     void * pvDummy3[ 4 ];
  6 };
  7 typedef struct xSTATIC_LIST_ITEM StaticListItem_t;
  8 
  9 /* 根据FreeRTOSConfig.h配置的不同结构体会有差异, 这是我的结果。
 10  * configMAX_TASK_NAME_LEN = 16
 11  * configTASK_NOTIFICATION_ARRAY_ENTRIES = 1 */
 12 typedef struct xSTATIC_TCB {
 13     void * pxDummy1;
 14     StaticListItem_t xDummy3[ 2 ];
 15     UBaseType_t uxDummy5;
 16     void * pxDummy6;
 17     uint8_t ucDummy7[ configMAX_TASK_NAME_LEN ];
 18     UBaseType_t uxDummy12[ 2 ];
 19     uint32_t ulDummy18[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
 20     uint8_t ucDummy19[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
 21     uint8_t uxDummy20;
 22 } StaticTask_t;
 23 
 24 
 25 static TCB_t * prvCreateStaticTask( TaskFunction_t pxTaskCode,
 26                                         const char * const pcName,
 27                                         const configSTACK_DEPTH_TYPE uxStackDepth,
 28                                         void * const pvParameters,
 29                                         UBaseType_t uxPriority,
 30                                         StackType_t * const puxStackBuffer,
 31                                         StaticTask_t * const pxTaskBuffer,
 32                                         TaskHandle_t * const pxCreatedTask )
 33     {
 34         TCB_t * pxNewTCB;
 35 
 36         configASSERT( puxStackBuffer != NULL );
 37         configASSERT( pxTaskBuffer != NULL );
 38 
 39         #if ( configASSERT_DEFINED == 1 )
 40         {
 41             /* Sanity check that the size of the structure used to declare a
 42              * variable of type StaticTask_t equals the size of the real task
 43              * structure. */
 44              /* 确保静态的TCB和TCB_t大小是一致的，一般是一致的 */
 45             volatile size_t xSize = sizeof( StaticTask_t );
 46             configASSERT( xSize == sizeof( TCB_t ) );
 47             ( void ) xSize; /* Prevent unused variable warning when configASSERT() is not used. */
 48         }
 49         #endif /* configASSERT_DEFINED */
 50 
 51         if( ( pxTaskBuffer != NULL ) && ( puxStackBuffer != NULL ) )
 52         {
 53             /* The memory used for the task's TCB and stack are passed into this
 54              * function - use them. */
 55             /* MISRA Ref 11.3.1 [Misaligned access] */
 56             /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-113 */
 57             /* coverity[misra_c_2012_rule_11_3_violation] */
 58             pxNewTCB = ( TCB_t * ) pxTaskBuffer;
 59             ( void ) memset( ( void * ) pxNewTCB, 0x00, sizeof( TCB_t ) );
 60             pxNewTCB->pxStack = ( StackType_t * ) puxStackBuffer;
 61 
 62             #if ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 )
 63             {
 64                 /* Tasks can be created statically or dynamically, so note this
 65                  * task was created statically in case the task is later deleted. */
 66                  /* 标记任务是静态创建的 */
 67                 pxNewTCB->ucStaticallyAllocated = tskSTATICALLY_ALLOCATED_STACK_AND_TCB;
 68             }
 69             #endif /* tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE */
 70 
 71             /* 初始化任务参数，后面会讲到 */
 72             prvInitialiseNewTask( pxTaskCode, pcName, uxStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB, NULL );
 73         }
 74         else
 75         {
 76             pxNewTCB = NULL;
 77         }
 78 
 79         return pxNewTCB;
 80     }
 81 /*-----------------------------------------------------------*/
 82 
 83     /* pxTaskCode：任务入口；
 84      * pcName：任务名称；
 85      * uxStackDepth：任务栈深；
 86      * pvParameters：任务形参；
 87      * uxPriority：任务优先级；
 88      * puxStackBuffer：任务栈，用户提供内存；
 89      * pxTaskBuffer：任务TCB数据存放，用户提供内存。 */
 90     TaskHandle_t xTaskCreateStatic( TaskFunction_t pxTaskCode,
 91                                     const char * const pcName,
 92                                     const configSTACK_DEPTH_TYPE uxStackDepth,
 93                                     void * const pvParameters,
 94                                     UBaseType_t uxPriority,
 95                                     StackType_t * const puxStackBuffer,
 96                                     StaticTask_t * const pxTaskBuffer )
 97     {
 98         TaskHandle_t xReturn = NULL;
 99         TCB_t * pxNewTCB;
100 
101         /* 设置任务，初始化参数 */
102         pxNewTCB = prvCreateStaticTask( pxTaskCode, pcName, uxStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer, &xReturn );
103 
104         if( pxNewTCB != NULL )
105         {
106             prvAddNewTaskToReadyList( pxNewTCB );   /* 加入到就绪列表中，后面会讲到 */
107         }
108         else
109         {
110             mtCOVERAGE_TEST_MARKER();
111         }
112 
113         return xReturn;
114     }

 1 static TCB_t * prvCreateTask( TaskFunction_t pxTaskCode,
 2                                    const char * const pcName,
 3                                    const configSTACK_DEPTH_TYPE uxStackDepth,
 4                                    void * const pvParameters,
 5                                    UBaseType_t uxPriority,
 6                                    TaskHandle_t * const pxCreatedTask )
 7 {
 8     TCB_t * pxNewTCB;
 9 
10 
11     StackType_t * pxStack;
12 
13     /* 在堆栈管理的文章中有介绍过，申请内存
14      * #define pvPortMallocStack    pvPortMalloc
15      * #define vPortFreeStack       vPortFree */
16     pxStack = pvPortMallocStack( ( ( ( size_t ) uxStackDepth ) * sizeof( StackType_t ) ) );
17 
18     if( pxStack != NULL )
19     {
20         /* Allocate space for the TCB. */
21         pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) );
22 
23         if( pxNewTCB != NULL )
24         {
25             ( void ) memset( ( void * ) pxNewTCB, 0x00, sizeof( TCB_t ) );
26 
27             /* Store the stack location in the TCB. */
28             pxNewTCB->pxStack = pxStack;
29         }
30         else
31         {
32             /* The stack cannot be used as the TCB was not created.  Free
33              * it again. */
34             vPortFreeStack( pxStack );
35         }
36     }
37     else
38     {
39         pxNewTCB = NULL;
40     }
41 
42     if( pxNewTCB != NULL )
43     {
44         #if ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 )
45         {
46             /* Tasks can be created statically or dynamically, so note this
47              * task was created dynamically in case it is later deleted. */
48             /* 标记任务是动态创建的 */
49             pxNewTCB->ucStaticallyAllocated = tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB;
50         }
51         #endif /* tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE */
52 
53         /* 初始化任务参数，后面会讲到 */
54         prvInitialiseNewTask( pxTaskCode, pcName, uxStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB, NULL );
55     }
56 
57     return pxNewTCB;
58 }
59 /*-----------------------------------------------------------*/
60 
61 /* 这里的形参就不介绍了，应该都比较清楚 */
62 BaseType_t xTaskCreate( TaskFunction_t pxTaskCode,
63                             const char * const pcName,
64                             const configSTACK_DEPTH_TYPE uxStackDepth,
65                             void * const pvParameters,
66                             UBaseType_t uxPriority,
67                             TaskHandle_t * const pxCreatedTask )
68 {
69     TCB_t * pxNewTCB;
70     BaseType_t xReturn;
71 
72     /* 设置任务，初始化参数 */
73     pxNewTCB = prvCreateTask( pxTaskCode, pcName, uxStackDepth, pvParameters, uxPriority, pxCreatedTask );
74 
75     if( pxNewTCB != NULL )
76     {
77         prvAddNewTaskToReadyList( pxNewTCB );   /* 加入到就绪列表中，后面会讲到 */
78         xReturn = pdPASS;
79     }
80     else
81     {
82         xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
83     }
84 
85     return xReturn;
86 }

  1 static void prvInitialiseNewTask( TaskFunction_t pxTaskCode,
  2                                   const char * const pcName,
  3                                   const configSTACK_DEPTH_TYPE uxStackDepth,
  4                                   void * const pvParameters,
  5                                   UBaseType_t uxPriority,
  6                                   TaskHandle_t * const pxCreatedTask,
  7                                   TCB_t * pxNewTCB,
  8                                   const MemoryRegion_t * const xRegions )
  9 {
 10     StackType_t * pxTopOfStack;
 11     UBaseType_t x;
 12 
 13     /* Calculate the top of stack address.  This depends on whether the stack
 14      * grows from high memory to low (as per the 80x86) or vice versa.
 15      * portSTACK_GROWTH is used to make the result positive or negative as required
 16      * by the port. */
 17     #if ( portSTACK_GROWTH < 0 )
 18     {
 19         /* 往前走4个字节，因为这个栈是先存值，再移动指针，所以需要确保栈顶指针指向栈空间的最后一个有效位置 */
 20         pxTopOfStack = &( pxNewTCB->pxStack[ uxStackDepth - ( configSTACK_DEPTH_TYPE ) 1 ] );
 21         /* 栈需要对齐 */
 22         pxTopOfStack = ( StackType_t * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );
 23 
 24         /* Check the alignment of the calculated top of stack is correct. */
 25         configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0U ) );
 26     }
 27     #endif
 28 
 29     /* Store the task name in the TCB. */
 30     if( pcName != NULL )
 31     {
 32         for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )
 33         {
 34             pxNewTCB->pcTaskName[ x ] = pcName[ x ];
 35 
 36             /* Don't copy all configMAX_TASK_NAME_LEN if the string is shorter than
 37              * configMAX_TASK_NAME_LEN characters just in case the memory after the
 38              * string is not accessible (extremely unlikely). */
 39             if( pcName[ x ] == ( char ) 0x00 )
 40             {
 41                 break;
 42             }
 43             else
 44             {
 45                 mtCOVERAGE_TEST_MARKER();
 46             }
 47         }
 48 
 49         /* Ensure the name string is terminated in the case that the string length
 50          * was greater or equal to configMAX_TASK_NAME_LEN. */
 51         pxNewTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1U ] = '\0';
 52     }
 53     else
 54     {
 55         mtCOVERAGE_TEST_MARKER();
 56     }
 57 
 58     /* This is used as an array index so must ensure it's not too large. */
 59     configASSERT( uxPriority < configMAX_PRIORITIES );
 60 
 61     if( uxPriority >= ( UBaseType_t ) configMAX_PRIORITIES )
 62     {
 63         uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;
 64     }
 65     else
 66     {
 67         mtCOVERAGE_TEST_MARKER();
 68     }
 69 
 70     pxNewTCB->uxPriority = uxPriority;
 71 #if ( configUSE_MUTEXES == 1 )
 72     {
 73         pxNewTCB->uxBasePriority = uxPriority;    /* 用于优先级继承机制 */
 74     }
 75 #endif /* configUSE_MUTEXES */
 76 
 77     vListInitialiseItem( &( pxNewTCB->xStateListItem ) );
 78     vListInitialiseItem( &( pxNewTCB->xEventListItem ) );
 79 
 80     /* Set the pxNewTCB as a link back from the ListItem_t.  This is so we can get
 81      * back to  the containing TCB from a generic item in a list. */
 82     /* 设置ListItem_t的持有者，这样可以从Item处获取到TCB */
 83     listSET_LIST_ITEM_OWNER( &( pxNewTCB->xStateListItem ), pxNewTCB );
 84 
 85     /* Event lists are always in priority order. */
 86     /* 事件列表总是按优先级排序，具体的可以等解析事件的时候再会过来看为什么这么设置 */
 87     listSET_LIST_ITEM_VALUE( &( pxNewTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxPriority );
 88     listSET_LIST_ITEM_OWNER( &( pxNewTCB->xEventListItem ), pxNewTCB );
 89 
 90     /* Initialize the TCB stack to look as if the task was already running,
 91      * but had been interrupted by the scheduler.  The return address is set
 92      * to the start of the task function. Once the stack has been initialised
 93      * the top of stack variable is updated. */
 94     #if ( portUSING_MPU_WRAPPERS == 0 )
 95     {
 96         /* If the port has capability to detect stack overflow,
 97          * pass the stack end address to the stack initialization
 98          * function as well. */
 99         #if ( portHAS_STACK_OVERFLOW_CHECKING == 0 )
100         {
101             /* 初始化栈，伪造一个现场 */
102             pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters );
103         }
104         #endif /* portHAS_STACK_OVERFLOW_CHECKING */
105     }
106     #endif /* portUSING_MPU_WRAPPERS */
107 
108     if( pxCreatedTask != NULL )
109     {
110         /* Pass the handle out in an anonymous way.  The handle can be used to
111          * change the created task's priority, delete the created task, etc.*/
112         *pxCreatedTask = ( TaskHandle_t ) pxNewTCB;
113     }
114     else
115     {
116         mtCOVERAGE_TEST_MARKER();
117     }
118 }

 1 static void prvAddNewTaskToReadyList( TCB_t * pxNewTCB )
 2 {
 3     /* Ensure interrupts don't access the task lists while the lists are being
 4      * updated. */
 5     /* 会操作任务列表，所以需要进入临界区，防止有系统中断打断 */
 6     taskENTER_CRITICAL();
 7     {
 8         uxCurrentNumberOfTasks = ( UBaseType_t ) ( uxCurrentNumberOfTasks + 1U );
 9 
10         if( pxCurrentTCB == NULL )
11         {
12             /* There are no other tasks, or all the other tasks are in
13              * the suspended state - make this the current task. */
14             pxCurrentTCB = pxNewTCB;
15 
16             if( uxCurrentNumberOfTasks == ( UBaseType_t ) 1 )
17             {
18                 /* This is the first task to be created so do the preliminary
19                  * initialisation required.  We will not recover if this call
20                  * fails, but we will report the failure. */
21                 /* 第一个任务被创建，需要先初始化任务列表，具体流程后面会解析 */
22                 prvInitialiseTaskLists();
23             }
24             else
25             {
26                 mtCOVERAGE_TEST_MARKER();
27             }
28         }
29         else
30         {
31             /* If the scheduler is not already running, make this task the
32              * current task if it is the highest priority task to be created
33              * so far. */
34             /* 
35             如果调度器未被运行且这是至今为止创建的最高优先级的任务，则把此任务作为当前任务 */
36             if( xSchedulerRunning == pdFALSE )
37             {
38                 if( pxCurrentTCB->uxPriority <= pxNewTCB->uxPriority )
39                 {
40                     pxCurrentTCB = pxNewTCB;
41                 }
42                 else
43                 {
44                     mtCOVERAGE_TEST_MARKER();
45                 }
46             }
47             else
48             {
49                 mtCOVERAGE_TEST_MARKER();
50             }
51         }
52 
53         uxTaskNumber++;
54 
55         prvAddTaskToReadyList( pxNewTCB );    // 真正的操作列表，放进去
56 
57         portSETUP_TCB( pxNewTCB );
58     }
59     taskEXIT_CRITICAL();
60 
61     if( xSchedulerRunning != pdFALSE )
62     {
63         /* If the created task is of a higher priority than the current task
64          * then it should run now. */
65         /* 如果创建的任务优先级比当前任务高，则yield */
66         taskYIELD_ANY_CORE_IF_USING_PREEMPTION( pxNewTCB );
67     }
68     else
69     {
70         mtCOVERAGE_TEST_MARKER();
71     }
72 }

 1 static void prvInitialiseTaskLists( void )
 2 {
 3     UBaseType_t uxPriority;
 4 
 5     /* 初始化所有的任务列表，包括就绪、阻塞、停止列表等 */
 6     for( uxPriority = ( UBaseType_t ) 0U; uxPriority < ( UBaseType_t ) configMAX_PRIORITIES; uxPriority++ )
 7     {
 8         vListInitialise( &( pxReadyTasksLists[ uxPriority ] ) );
 9     }
10 
11     vListInitialise( &xDelayedTaskList1 );
12     vListInitialise( &xDelayedTaskList2 );
13     vListInitialise( &xPendingReadyList );
14 
15     #if ( INCLUDE_vTaskDelete == 1 )
16     {
17         vListInitialise( &xTasksWaitingTermination );
18     }
19     #endif /* INCLUDE_vTaskDelete */
20 
21     #if ( INCLUDE_vTaskSuspend == 1 )
22     {
23         vListInitialise( &xSuspendedTaskList );
24     }
25     #endif /* INCLUDE_vTaskSuspend */
26 
27     /* Start with pxDelayedTaskList using list1 and the pxOverflowDelayedTaskList
28      * using list2. */
29     pxDelayedTaskList = &xDelayedTaskList1;
30     pxOverflowDelayedTaskList = &xDelayedTaskList2;
31 }