当前位置：
  1. 首页
  2. 精品源码
  3. CMS模板 / 插件
  4. WordPress
  5. 正文

想了解更多内容，请访问：

51CTO和华为官方战略合作共建的鸿蒙技术社区

https://harmonyos.51cto.com

继续分析鸿蒙轻内核源码，我们本文开始要分析下任务及任务调度模块。首先，我们介绍下任务栈的基础概念。任务栈{ ? = T D是高地址向低地址生长的递减栈` e X 7 U )，栈指针指向即将入栈的元素位置。初始化后未使用过的栈空间初始化的内容为宏OS_TASK_STACK_( – O s S D ]INIT代表的数值0xCACAt m G H p 9 sCACA，栈顶初始化为宏OS_TASK_MAGIC_WORD代表的数值0xCCCCCCCC。一个任务栈的示意图如下，其中，栈底指针是栈的最大的内存地址，栈顶指针，是栈的最小的内存地址，栈指针从栈底向栈顶方向生长。

任务上下文(Task Context)是任Q 8 6 E _务及2 C y 7 # Z ^ {任务调度模块的另N P A M n j X 3 w外一个重要的概念，它指的是任t E p T # | m务运行的环境，例如包括程序计数器} 4 o ? – q 9、堆栈指针、通用寄存器等内容。在多任务调度中f T V m S f 9 : q，任务上下文切换(Task Context Switching)属于核心内容，是多个任务运行在同一CPU核上的基础。在任务调V C m \ V J ) $ g度时，保存退出运行状态的任务使用的寄存器信息到任务栈，还会从W 3 5 0 ? K进入运行! 4 T V 0 ~状态的任务的栈中读取上下文信息，恢复寄存器信息。$ D h ^

下面，我们剖析下任务v E [ 5栈、任务栈初始化的源代码，若涉及开发板部分，以开发板工程targets\cortex-m7_nucleo_f767zi_gccj Q ~ b y n B\为例进行源码分析。首先，看下任务上下文结构体。

1、TaskContext上下文结构体定义

在文件kernel\arch\arm\cortex-m7W N n\gcc\los_arch_{ ] J K E V a a ccontext.h中，定义的上下文的结构体如下，主要是浮点寄L . L G # U存器，通用寄存器。

    

  1. typ; J 1 hedefstructTagTskContext{
    2. 

  2. #if((defined(__FPU_PRb n r K n - J EESENT)&&(__FPU_PRESENT==1U))&&\
    3. 

  3. (defined(__FPU_USED)&&(__FPU_USED==1U)))
    4. 

  4. UINT32S16;
    5. 

  5. UIN~ . ~ m RT32S1? i ] i W7;
    6. 

  6. UINT32S18;
    7. 

  7. UINT32S19;
    8. 

  8. UINT32| Y AS20;
    9. 

  9. UINT32SN H 7 o 9 8 M21;
    10. 

  10. UINT32S22;
    11. 

  11. UINT32S23;
    12. 

  12. UINT32S24;
    13. 

  13. UINT3Z W y - \2S25;
    14. 

  14. UINT32S26;
    15. 

  15. UINT32S27;
    16. 

  16. UINT32S28;
    17. 

  17. UINT32S29;
    18. 

  18. UINT32S30;
    19. 

  19. UINT32S31;
    20. 

  20. #end& ~ x % Hif
    21. 

  21. UINT32uwR4;
    22. 

  22. UINT32uwR5;
    23. 

  23. UINT32uwR6;
    24. 

  24. UINv f _ k \ 1 } UT32uwR7;
    25. 

  25. UINT32uwR8;
    26. 

  26. UINT32uwR9;
    27. 

  27. UINT32uwR10;
    28. 

  28. UINT32uwR11;
    29. 

  29. UINT32uwPriMask;
    30. 

  30. UINT32uwR0;
    31. 

  31. UINT32uwR1;
    32. 

  32. UINT32uwR2~ Q z i | d , s;
    33. 

  33. UINT32uwR3;
    34. 

  34. U^ z oINT32uwR12;
    35. 

  35. UINT32uwLR;
    36. 

  36. UINT32uwPC;
    37. 

  37. UINT32uwxPSR;
    38. 

  38. #if((defined(__FPU_PRESENT)\ 7 Q&t E 5 C ! r&(__FPU_PRESENT==1U))* V ; + - - f a&&\
    39. 

  39. (defined(__FPU_USED)&&(__FPU_USED==1U)))
    40. 

  40. UINT32S0;
    41. 

  41. UINT32S1;
    42. 

  42. UINT32S2;
    43. 

  43. UINd 6 0 wT32S3;
    44. 

  44. UINT32S4;
    45. 

  45. UINT32S5;
    46. 

  46. UINT32S6;
    47. 

  47. UINT32S7;
    48. 

  48. UINT32S8c u E m;
    49. 

  49. UINT32S9;
    50. 

  50. UINT32S10;
    51. 

  51. UINT32S11;
    52. 

  52. UINT32S12;
    53. 

  53. UINT32S13;
    54. 

  54. UINT32S14;
    55. 

  55. UINT32S15;
    56. 

  56. UINT) G A 9 [ h32FPSCR;
    57. 

  57. UINT32NOj [ 7_NAME;
    58. 

  58. #endif
    59. 

  59. }TaskContext;
    60.

2、任务u | a栈相关函t I # ~ @数

2.1 任务栈初始化函数

在文件kernel\arch\arm\cortex-m7\gcc\los_c@ ` ? M / n Context.c中定义了任务栈初始化函数VOID *HalTsl ~ S G 1 . ? ( ?kStackInit(t()。该函数被文件kernel\src\los_task.c中的函数UINT32 OsNewTaskInit()调用完成任务初始化，并进一步在创建任务函数UINT32 LOS_TaskCreateOne _ o 4 g i a hly()中调用，完成新创建任务的y \ z \ e n任务栈初始化。

该函数使用3个参数，一个是任务编号UINT32 taskID，一个是初始化的栈的大小UINT32 stac1 l ] JkSize，第3个参数是栈顶C x \指针VOID *topStack。⑴处代码把栈内容初始= ; , r % d化\ w z为OS_TASK_STACK_IN| r / JIT，⑵处把栈顶初始化为OS_TASK_MAGIC_WORDo X P k y y B。

⑶处代码获取任务上下文的指针地h T N D )址TaskContext *context。对O S A E | e u于新创建任务，从栈的底部开始，大小为sizeof(TaskCons T l xtext)的栈空间存放上9 W S g E ) 0 ` 0下文的数据。⑷处如果支持浮点数计算，需要初始化浮点数相关的寄存器。⑸初始化通用寄存器，其中.uwLR初始化为(UINT32)@ @ x 7 / s \ 4(UINTPTR)HalSysExit。.5 e H P d } 4uwPC初始化为(UINT32)(UINTPTR)OsTaskEntry，这是CPU首次执行该任务时运行的第J W x u一条指令的位置。这2个V j k , 4函数下文会分析。

⑹处返回值是指针(VOID *)taskContext，这个就是任务初始化后的栈指针，注意不是从栈底开始了，栈底保存的是上下文，栈指针要减去上下文占用的栈大小。在栈中，从TaskContext *context指针增加的方向，依次保存上下文结构体的第一个成员，第二个成员…另外，初始化栈的时候，除了特殊的几个寄存器，不同寄存器的初始值虽然没有什么意义，也有些初始化的规律。比如R2寄存器初始化为0x02020202L，R12寄存器初始化为0x12121212L初始化的内容和寄存器编号有关联，其余类似@ l U t w。

    

  1. LITE_OS_SEC_TEXT_INITVOID*HalTskStackInit(UINT32taskIc | v ^ ;D,UINT32stackSize,VOID*topStack)
    2. 

  2. {
    3. 

  3. TaskContext*contexx 2 t Q s R Kt=NULL;
    4. 

  4. errno_tresult;
    5. 

    6. 

  6. /*initializethetaskstack,writemagicn7 _ Dumtostacktop*/
    7. 

  7. ⑴result=memset_s(topStack,stackSi# E ] P M C Q pze,(INT32)(OSd & m = ] & j ;_TASK_STACn } * f 5 ( v _K_INIT&0xFF),stackSize);
    8. 

  8. if(result!=EOK){
    9. 

  9. printf("memset_sisfailed:%s[%d]\r\n",__FUNCTION__,__LINE__);
    10. 

  10. }
    11. 

  11. ⑵*((UINT32*)a O U(topStack))=OS_TASK_MAGIC_WORD;
    12. 

    13. 

  13. ⑶context=(TaskContext*)(((UINTPTR)topStack+stackSize)-sizeof(TaskContext)6 2 5 G I u);
    14. 

    15. 

  15. #if((defined(__FPU_PRESE] 2 h N ~ B k 8NT)&&(__FPU_PRESENT==1U))&&a+ ` \ A 3mp;\
    16. 

  16. (defined(__FPU_USED)&&(__FPU_USED==1U)))
    17. 

  17. ⑷context->S16=0xAA000010;
    18. 

  18. context->S17=0xAA000011;
    19. 

  19. context->S18=0xAA000012;
    20. 

  20. c* _ X { p B K Vontext->S19=0xAA000013;
    21. 

  21. context->S20=0xAA000014;
    22. 

  22. context->S21=0xAA000015;
    23. 

  23. c% L 4ontext->S22=0xAA000016;
    24. 

  24. context->S23=0xAA000017;8 $ I C 9 ? 6 J F
    25. 

  25. context->S24=0xAA000018;
    26. 

  26. context->S25=0xAA000019;
    27. 

  27. context-B g q r r _ G N>S26=0xAA00001A;
    28. 

  28. context->S27=0xAA00001B;
    29. 

  29. context->S28=0xAA00001C;
    30. 

  30. conteP l \ Qxt->S29m ~ \ 4=0xAA00001D;
    31. 

  31. context->S30=0xAA00001E;
    32. 

  32. context->S31=0xAA00001F;
    33. 

  33. con\ k P z 9 3 0 3text->E { H y k 3 j i;S0=0xAA000000;
    34. 

  34. context->S1=0xAA000001;
    35. 

  35. contextd ` Q : } S ` q->X H . [ O E;S2=0xAAX H ! m ) t000002;
    36. 

  36. contexK + ct->S3=0xAA000003;
    37. 

  37. context-&? . 3gt;S4=0xAA000004;
    38. 

  38. context->S5=0xAAn $ m s000005;
    39. 

  39. context->S6=0xAA000006;
    40. 

  40. context->S7=0xAA000007;
    41. 

  41. context->S8=0xAA000008;
    42. 

  42. context-&= | 7 =gt;S9=0xAA000009;
    43. 

  43. context->S10=0xAA00000A;
    44. 

  44. context->S11=0xAA00000B;
    45. 

  45. context->h j @ P m $ |;S12=0xAA00000C;
    46. 

  46. context-| 7 4>S13) k # H 6 h 4=0xAA00000D;
    47. 

  47. context->S14=0xAA00000E;
    48. 

  48. context->S15=0xAA00000F;
    49. 

  49. context->FPSCR=0x00000000;
    50. 

  50. context->NO_NAME=0xAA000011;
    51. 

  51. #endif
    52. 

    53. 

  53. ⑸context->uwR4=0x04040404Lu T e d i l;
    54. 

  54. context->u_ t : n %wR5=0x05050505L;
    55. 

  55. context->uwR6=0x06060606L;
    56. 

  56. context->uwR7=0x07070707L;
    57. 

  57. context->uwR8=0x08080808L;
    58. 

  58. context->uwR9=0x09090909L;
    59. 

  59. context->uwR10=0x10101010L;
    60. 

  60. context->uwR11=0x11111111L;
    61. 

  61. context->uk N RwPriMask=0;
    62. 

  62. context->uwR0=taskID;
    63. 

  63. context->uwR1=0x01010101L;
    64. 

  64. context->uwR2=0x02020202L;
    65. 

  65. context->uwR3=0x03030303L;
    66. 

  66. context->C u 3 ` H n CuwR12=0x1212/ i s \ g 21212L;
    67. 

  67. context->uwLR=(UINT32)(UIt h O q | 3 j %NTPTR)HalSysExit;
    68. 

  68. contex4 ; J [ I X \t->uwPC=(UINT32)(UINTPTR)OsTaskEntry;
    69. 

  69. context-b G g p ~ X h>uwxPSR=0 s f * [ ; C N0xi & [ d n v +01000000L;
    70. 

    71. 

  71. ⑹return(Vm - z tOID*)context;
    72. 

  72. }
    73.

2.2 获取任务栈水线函数

随着任务栈入栈、出栈，当前栈使用的大小不一定是最大值~ ) F | 9 a，UINT32 OsGetTaskWaterLine(UINT32 taskID)可以获取的栈使用的最大值即水线WaterLine。该函数定义在文件k\ 2 N 7 Z $ 3 D gernel\src\los_task.c，它需要1个参数，即UINT32 taskID任务编号，返回值UINT32 peakUsed表示获取的水线; p C } 8 n z 9值，即任务栈使用的最大值。

我们详细看下代{ r ! 4码，⑴处代码表示如果u * ( L `栈顶等于设置的魔术字，说明栈没有被溢出破坏，从栈顶开始栈内容被写满4 ) W J宏OS] y Z Z `_TASK_STACK_INIT的部分是没有使用过的栈空间。使用临时l 2 & V % C \栈指% * 1 L = p \ C针stackPtr指针变量依次向栈底方向增加，判断栈是否被使用过，while循环结束，栈指针stackPtr指向最大的未使用过的栈地址。⑵处代码获取最大% X t d 9的使用过的栈空间大小，即需要的水线。⑶处如b B \ { x w w 6果栈顶溢出，则返回无效值OS_NULL_INT。

该函数被kernel\base\los) k G u_task.c中l ( _ b w } K的函数LOS_TaskInfoGet(UINT32 taskId, TSK_INFO_S *taskInfo)调用，获^ & } # ^取任务的信息。在shell模块也会使用来或者栈信息。

    

  1. UINT32OsStackWaterL/ ) ) = L v c \ineGet(constUINY ^ J cTPTR*stackBottom,constUINTPTR*stackTop,UINT32*peakUsed)
    2. 

  2. {
    3. 

  3. UINT32size;
    4. 

  4. constU1 O l + f / 8INTPTR*tmp=NULL;
    5. 

  5. ⑴if(*stackTop==OS_STACK_MAGIC_WORD){i M n P n + @
    6. 

  6. tmp=stackTop+1;
    7. 

  7. while((tmp<stackBottom)&&(*tmp==OS_STACK_INIT)){
    8. 

  8. tmp++;
    9. 

  9. }
    10. 

  10. ⑵size=(UINT32)((UINTPTR)stackBotto, R k 4 = 1 jm-(UINTPTR)tmp);
    11. 

  11. *peakUsed=(size==0)?size:(sizef M e+sizeof(CHAR*));
    12. 

  12. returnLOS_OK;
    13. 

  13. }else{
    14. 

  14. *peakUsed=OS_INVALID, ^ N $ c ? O_WATERLINE;
    15. 

  15. returnLOS_NOK;
    16. 

  16. }
    17. 

  17. }
    18. 


    

  1. UINT32OsGetTaskWaterLiX # `ne(UINT32taskID)
    2. 

  2. {
    3. 

  3. UIU z rNT32*stackPt8 ) U D A c Br=NULL;
    4. 

  4. UINT32peakUsed;
    5. 

    6. 

  6. ⑴if(*(UINT32*)(UINTPTR)OJ j = % US_TCB_FROM_TID(taskID)->topOfSt? R e = ) Back==OS_TASK_MAGIC_WORD){
    7. 

  7. stackPtr=(q N MUINT32*)(UINTPTR)(OS_TCB_FROM_/ 0 x 4 ^ C RTID(taskID)->topOfStack+OS_TASK_STACK_TOP_OFF` s @SET);
    8. 

  8. while((stackPtr<(UINT32*)(OS_TCB_FROM_TID(taskID)->stackPointer))&am# G X r S ! 2p;&(*stackPtr==OS_TASK_STA3 C P 5CK_INIT)){
    9. 

  9. stackPtr+=1;
    10. 

  10. }
    11. 

  11. ⑵peakUsed=OS_TCB_FROM_TID(taskID)->stackSize-
    12. 

  12. ((UINT32)(UINTPTR)stackPtr-OS_} f . * 6 n 4 ~TCB_FROM_TID(taskID)->topOfStack);
    13. 

  13. }else{$ ~ \ ` k k ^ Q
    14. 

  14. ⑶PRINT_ERR("CURREa | k L FNTtask%sstackoverflow!\n",OS_TCB_FROM_TID(taskID)->taskName);
    15. 

  15. peakUsed=OS_NULL_INT;
    16. 

  16. }
    17. 

  17. returnpeakUsed;
    18. 

  18. }
    19.

3、任务进入退K g J g出函数

3.1、任务退出函数

在初始化上下文的时候，链接寄存器设置的是函数(UINT32)(U& \ O O &INTPTR)HalSysExit，该函数定义在文件kernel\src\los_task.d / 8 . v 4c。函数代码里调用LOS_IntLock()关中断，然后进入死循环。在任务正常调度期间，该函: 0 W 4数理论上不会被执行。在系L k \统异常时，主动调用LOS_Panic()c触发异常时，也会调用该函数。

    

  1. LITE_OS_SEC_TEXT_MI0 V h wNORVOIw ? P x G y ADHalSysExit(VOID)
    2. 

  2. {
    3. 

  3. LOS_IntLock();
    4. 

  4. while(1){
    5. 

  5. }
    6. 

  6. }
    7.

3.2、任务进入函数

在初始化上下文的时候，PC寄存器设置的是函数VOID OsTaskEntry(UINT32 taskId)，该函数定义在文件kernel\base\los_task.c，我们来分析下源代码，⑴处代码获取taskCB，然后执行⑵调用任务的入口函数。等任务执行完毕后，y ^ q 3 C @ { f B执行⑶删除任务。通常任务入口执行函数都是while循环，任务不执行时，会调度到其他任务或者空闲任务，不会执行到删除任务阶段。

    

  1. LITE_OS_SEC_TEXT_INITVOIDOsTaskEntry(UINT32taskID)
    2. 

  2. {
    3. 

  3. UINT32retVal;
    4. 

  4. ⑴LosTaskCB*taskCB=OS_TCB_FROM_TID(taskID);
    5. 

    6. 

  6. ⑵(VOID)taskCB->taskEntry(taskCB->arg);
    7. 

    8. 

  8. ⑶retVal=LOS_TaskDelete(taskCB->taskID);
    9. 

  9. if(retVal!=LOS_OK){
    10. 

  10. PRINT_ERR("DeleteTask[TID:%d]Failed!\n",tasz 7 c 2 OkCB->taskI( i 3 6 x ~ eD);
    11. 

  11. }
    12. 

  12. }
    13.

小结

本文带领大家一起学习了鸿蒙轻内y B & m r 3 n核的任务栈、任务上下文的基础概念，剖R . c #析了任务栈初始化的代码。后续也会陆续推出更多的分享文章，敬请期待。

想I x s L ] i ? Z c了解更多内容，请访问：

51CTO和华为官方战略合作共建的鸿蒙技术社区

https://harmof D 5 ; Onyos.51cto.com

上一篇 从零搭建开发脚手架 使用MDC实现日志链路跟踪
下一篇 使用 Golang 的交叉编译

相关文章