l4中 mutex 实现的流程及代码分析

liu090

    只有多任务系统才需要mutex,这点应该不用解释,在l4系统中实现mutex 的本质
就是让无法获得mutex的任务,通过调度交出当前运行权,交由其他任务继续运行,
当获得mutex的任务在释放mutex时,如果发现有对metex的lock请求,也同样交出运行权,

  然后前面无法获得mutex的任务或将继续运行,重新进行lock mutex测试,然后继续上面的流程,

获得就继续运行,没有获得就交出运行权

先看下mutex的结构:

 

1. struct mutex {
   
2.     L4_Word_t fHolder;
   
3.     L4_Word_t fNeeded;
   
4.     L4_Word_t fCount;
   
5.     };

 

具体的流程图如下:

上图中如果 mutex lock  不成功,调用thread_swith切换到fHolder所保存的 ,已经成功mutex lock的

的thread

 

实现代码:

1. stmdb sp!, {r4, r5, lr} /* r4 and r5 are local variables,
3. lr needed when we do the syscall */
7. /* r4 -- saved lock address */
9. ldr r4, [r0]
11. /* Here we load the utcb address */
13. mov r3, #0xff000000
15. /* r5 -- saved UTCB address ,liunote see arch\arm\libs\l4\include\vregs.h */
17. ldr r5, [r3, #0xff0]        /* uctb => 0xff000ff0 */
21. /* From here r4 and r5 are safe, the thread_switch
23. syscall will not trash these registers */
27. /* r0 is tmp */
29. /* First we set the point at which we want to
31. be restarted in case of preemption */
33. adr r0, preempt_handler
35. str r0, [r5, #__L4_TCR_PREEMPT_CALLBACK_IP*4] /* preempt_callback_ip */
37. /* And then we enable the preemption callback to
39. occur */
41. mov r0, #32
43. strb r0, [r5, #TCR_PREEMPT_FLAGS] /* arch\arm\libs\l4\include\vregs.h __L4_TCR_PREEMPT_FLAGS 's last byte !!! */
45. LABEL(preempt_handler) /* If preempt we restart here */
47. /* r0 is lock holder */
49. ldr r0, [r4]
50. /* r1 is me (real tid is in the user-defined handle)*/
52. ldr r1, [r5, #__L4_TCR_USER_DEFINED_HANDLE*4]
54. /* test if lock holder is == 0 */
56. cmp r0, #0 /* mutex-> fHolder 为0,表示没有被占*/
58. beq grab_lock /* liunote , get lock ok !!! */
60. /* or if lock holder is me */
62. cmp r0, r1
64. beq exit_path /* We already have the lock so we jump forward to
66. the part where we turn off preemption and return */
68. /* we couldn't get the lock so we fall through to here */
70. /* r0 holds lock holder, will be argument to the system call */
72. /* r1 is temp */
76. /* Load syscall ptr */ /* liunote : r0 is lock holder (mutex-> fHolder), 然后L4_ThreadSwitch 切换到lock holer 去了 */
78. ldr ip, =L4_ThreadSwitch
82. mov r1, #1
84. str r1, [r4, #4] /* Let current lock holder know there is contention liunote [r4,#4] ==> mutex -> fNeeded =1 ,让目前holder 住的thread 知道有其他mutex 请求
86. so that it knows to yield at the end of its timeslice , 这样时间片到了要放弃,或者unlock muxtex时主动放弃*/
90. /* Load branch address */
92. ldr ip, [ip]
95. stmdb sp!, {r4-r11}
97. mov lr, pc
99. /* do the system call */
101. mov pc, ip
105. ldmia sp!, {r4-r11}
107. /* After syscall return to preempt_handler */ /* 没有lock 住的thread 到这里thread switch , 然后会切回来继续执行lock !!! */
109. b preempt_handler
111. LABEL(grab_lock)
113. /* The lock is free -- we try to grab it before being preempted */
115. /* r0 is tmp */
117. mov r0, #0
119. str r0, [r4, #4] /* If we get this far, then noone of a higher priority than liunote [r4,#4] ==> mutex -> fNeeded =0
121. us wants the lock, so we can unset the yield needed flag */
123. /* Now we store ourself as the lock handler, this is transaction complete, although
125. we still might be preempted right here, in which case we validaly have the lock
127. and the preempt handler will go through sucessfully */
129. str r1, [r4] /* mutex-> fHolder = thread user define handler (__L4_TCR_USER_DEFINED_HANDLE) !!! */
131. strb r0, [r5, #TCR_PREEMPT_FLAGS] /* liunote 设置utcb的__L4_TCR_PREEMPT_FLAGS 最后1byte 为0 */
133. ldmia sp!, {r4, r5, pc} /* RETURN POINT */
135. LABEL(exit_path)
137. /* Exit path that occurs if we were preempted, before returning --
139. same as above, however we need to zero, r0 first */
141. mov r0, #0
143. strb r0, [r5, #TCR_PREEMPT_FLAGS]
145. ldmia sp!, {r4, r5, pc} /* RETURN POINT */

 

mutex unlock 的实现很简单:

 

1. struct mutex *mtx = (struct mutex *) *mutex;
   
2.     mtx->fHolder = 0;
   
3. 
   
4.     if (mtx->fNeeded) {
   
5.     mtx->fNeeded = 0;
   
6.     L4_ThreadSwitch(L4_nilthread); /*
   
7.     }

 

关于L4_ThreadSwitch 切到nil thread,表示放弃运行,交由系统调度