void vTaskStartScheduler( void )
{
	BaseType_t xReturn;
	xReturn = prvCreateIdleTasks();
	
	#if ( configUSE_TIMERS == 1 )
    {
        if( xReturn == pdPASS )
        {
            xReturn = xTimerCreateTimerTask();
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }
    #endif /* configUSE_TIMERS */
    /* The return value for xPortStartScheduler is not required
         * hence using a void datatype. */
        ( void ) xPortStartScheduler();
}

可以看出，开始调度函数一般就做这些事：

1. 创建空闲任务
2. 如果使用了定时器，则创建定时器守护函数
3. 调用 xPortStartScheduler()，这个函数又与硬件强相关

我们来看 /portable/GCC/ARM_CM4F/port.c 中的 xPortStartScheduler()

...
/* Start the first task. */
    prvPortStartFirstTask();
...

再看 prvPortStartFirstTask()，可以看到已经到汇编了，最重点的就是 svc 0 这个指令，直接触发了SVC中断。

static void prvPortStartFirstTask( void )
{
    /* Start the first task.  This also clears the bit that indicates the FPU is
     * in use in case the FPU was used before the scheduler was started - which
     * would otherwise result in the unnecessary leaving of space in the SVC stack
     * for lazy saving of FPU registers. */
    __asm volatile (
        " ldr r0, =0xE000ED08   \n" /* Use the NVIC offset register to locate the stack. */
        " ldr r0, [r0]          \n"
        " ldr r0, [r0]          \n"
        " msr msp, r0           \n" /* Set the msp back to the start of the stack. */
        " mov r0, #0            \n" /* Clear the bit that indicates the FPU is in use, see comment above. */
        " msr control, r0       \n"
        " cpsie i               \n" /* Globally enable interrupts. */
        " cpsie f               \n"
        " dsb                   \n"
        " isb                   \n"
        " svc 0                 \n" /* System call to start first task. */
        " nop                   \n"
        " .ltorg                \n"
        );
}

/* Tick increment should occur on every kernel timer event. Core 0 has the
     * responsibility to increment the tick, or increment the pended ticks if the
     * scheduler is suspended.  If pended ticks is greater than zero, the core that
     * calls xTaskResumeAll has the responsibility to increment the tick. */
    if( uxSchedulerSuspended == ( UBaseType_t ) 0U )
    {
        /* Minor optimisation.  The tick count cannot change in this
         * block. */  //1，增加计数
        const TickType_t xConstTickCount = xTickCount + ( TickType_t ) 1;

        /* Increment the RTOS tick, switching the delayed and overflowed
         * delayed lists if it wraps to 0. */
        xTickCount = xConstTickCount;

        if( xConstTickCount == ( TickType_t ) 0U )
        {
            taskSWITCH_DELAYED_LISTS();//2，切换链表指针
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }

/* See if this tick has made a timeout expire.  Tasks are stored in
        * the  queue in the order of their wake time - meaning once one task
        * has been found whose block time has not expired there is no need to
        * look any further down the list. */
       if( xConstTickCount >= xNextTaskUnblockTime )
       {
           for( ; ; )
           {
               if( listLIST_IS_EMPTY( pxDelayedTaskList ) != pdFALSE )
               {
                   /* The delayed list is empty.  Set xNextTaskUnblockTime
                    * to the maximum possible value so it is extremely
                    * unlikely that the
                    * if( xTickCount >= xNextTaskUnblockTime ) test will pass
                    * next time through. */
                      //如果没有阻塞任务，则将其设为最大值，以便不进入大if判断中，而这个xNextTaskUnblockTime是个全局变量，有阻塞任务时会更新
                   xNextTaskUnblockTime = portMAX_DELAY;
                   break;
               }
               else
               {
                   /* The delayed list is not empty, get the value of the
                    * item at the head of the delayed list.  This is the time
                    * at which the task at the head of the delayed list must
                    * be removed from the Blocked state. */
                   /* MISRA Ref 11.5.3 [Void pointer assignment] */
                   /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */
                   /* coverity[misra_c_2012_rule_11_5_violation] */
                   pxTCB = listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList );
                   xItemValue = listGET_LIST_ITEM_VALUE( &( pxTCB->xStateListItem ) );
                   
                   if( xConstTickCount < xItemValue )
                   {
                       /* It is not time to unblock this item yet, but the
                        * item value is the time at which the task at the head
                        * of the blocked list must be removed from the Blocked
                        * state -  so record the item value in
                        * xNextTaskUnblockTime. */
                          //记录所有任务中离就绪时间最短的
                       xNextTaskUnblockTime = xItemValue;
                       break;
                   }
                   else
                   {
                       mtCOVERAGE_TEST_MARKER();
                   }

                   /* It is time to remove the item from the Blocked state. */
                   listREMOVE_ITEM( &( pxTCB->xStateListItem ) );

                   /* Is the task waiting on an event also?  If so remove
                    * it from the event list. */
                   if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )
                   {
                       listREMOVE_ITEM( &( pxTCB->xEventListItem ) );
                   }
                   else
                   {
                       mtCOVERAGE_TEST_MARKER();
                   }

                   /* Place the unblocked task into the appropriate ready
                    * list. */
                      //加入就绪链表
                   prvAddTaskToReadyList( pxTCB );

/* Tasks of equal priority to the currently running task will share
         * processing time (time slice) if preemption is on, and the application
         * writer has not explicitly turned time slicing off. */
        #if ( ( configUSE_PREEMPTION == 1 ) && ( configUSE_TIME_SLICING == 1 ) )
        //本质就是判断链表长度嘛
        {
            #if ( configNUMBER_OF_CORES == 1 )
            {
                if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ pxCurrentTCB->uxPriority ] ) ) > 1U )
                {
                    xSwitchRequired = pdTRUE;
                }
                else
                {
                    mtCOVERAGE_TEST_MARKER();
                }
            }