asp/extension/mutex/test/test_mutex4.c

   1 /*
   2  *  TOPPERS Software
   3  *      Toyohashi Open Platform for Embedded Real-Time Systems
   4  *
   5  *  Copyright (C) 2007-2009 by Embedded and Real-Time Systems Laboratory
   6  *              Graduate School of Information Science, Nagoya Univ., JAPAN
   7  *
   8  *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
   9  *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
  10  *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
  11  *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
  12  *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
  13  *      スコード中に含まれていること．
  14  *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
  15  *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
  16  *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
  17  *      の無保証規定を掲載すること．
  18  *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
  19  *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
  20  *      と．
  21  *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
  22  *        作権表示，この利用条件および下記の無保証規定を掲載すること．
  23  *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
  24  *        報告すること．
  25  *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
  26  *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
  27  *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
  28  *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
  29  *      免責すること．
  30  *
  31  *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
  32  *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
  33  *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
  34  *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
  35  *  の責任を負わない．
  36  *
  37  *  @(#) $Id: test_mutex4.c 1696 2010-01-01 16:01:25Z ertl-hiro $
  38  */
  39
  40 /*
  41  *              ミューテックスのテスト(4)
  42  *
  43  * 【テストの目的】
  44  *
  45  *  優先度上限ミューテックスに対して，loc_mtxとunl_mtxに伴う優先度の変
  46  *  更処理を網羅的にテストする．ただし，change_priorityと
  47  *  mutex_calc_priorityの内容には踏み込まない．
  48  *
  49  * 【テスト項目】
  50  *
  51  *      (A) ミューテックスのロック処理（loc_mtx）に伴う優先度変更
  52  *              (A-1) ロックしたミューテックスの優先度上限が自タスクの現在優先
  53  *                        度よりも高い場合に，自タスクの優先度がその優先度上限まで
  54  *                        上がること．また，同じ優先度内での優先順位が最高になるこ
  55  *                        と
  56  *              (A-2) ロックしたミューテックスの優先度上限が自タスクの現在優先
  57  *                        度と同じ場合に，自タスクの優先度が変わらないこと．また，
  58  *                        同じ優先度内での優先順位が変わらないこと
  59  *              (A-3) ロックしたミューテックスの優先度上限が自タスクの現在優先
  60  *                        度よりも低い場合に，自タスクの優先度が変わらないこと．ま
  61  *                        た，同じ優先度内での優先順位が変わらないこと
  62  *      (B) ミューテックスのロック解除処理（unl_mtx）に伴うロック解除した
  63  *              タスクの優先度変更
  64  *              (B-1) ロック解除したミューテックスの上限優先度が自タスクの現在
  65  *                        優先度と同じで，ミューテックスのロック解除で優先度が下が
  66  *                        るべき場合に，自タスクの優先度が適切に下げられること．ま
  67  *                        た，同じ優先度内での優先順位が最高になること
  68  *              (B-2) ロック解除したミューテックスの上限優先度が自タスクの現在
  69  *                        優先度と同じで，ミューテックスのロック解除で優先度が変わ
  70  *                        るべきでない場合に，自タスクの優先度が変わらないこと．ま
  71  *                        た，同じ優先度内での優先順位が変わらないこと
  72  *              (B-3) ロック解除したミューテックスの上限優先度が自タスクの現在
  73  *                        優先度よりも低い場合に，自タスクの優先度が変わらないこと．
  74  *                        また，同じ優先度内での優先順位が変わらないこと
  75  *      (C) ミューテックスのロック解除処理（unl_mtx）に伴いミューテックスを
  76  *              ロックしたタスクの優先度変更
  77  *              (C-1) ミューテックスの優先度上限が新たにミューテックスをロック
  78  *                        したタスクの現在優先度よりも高い場合に，当該タスクの優先
  79  *                        度がその優先度上限まで上がること．また，同じ優先度内での
  80  *                        優先順位が最低になること
  81  *              (C-2) ミューテックスの優先度上限が新たにミューテックスをロック
  82  *                        したタスクの現在優先度と同じ場合に，当該タスクの優先度が
  83  *                        変わらないこと．また，同じ優先度内での優先順位が最低にな
  84  *                        ること
  85  *              (C-3) ミューテックスの優先度上限が新たにミューテックスをロック
  86  *                        したタスクの現在優先度よりも低い場合に，当該タスクの優先
  87  *                        度が変わらないこと．また，同じ優先度内での優先順位が最低
  88  *                        になること
  89  *      (D) ミューテックスのロック処理（loc_mtx）のE_ILUSEエラー
  90  *              (D-1) 自タスクのベース優先度が，ロックしようとしたミューテック
  91  *                        スの上限優先度よりも高い時，E_ILUSEエラーになること
  92  *              (D-2) 自タスクのベース優先度が，ロックしようとしたミューテック
  93  *                        スの上限優先度と同じかそれより低ければ，自タスクの現在優
  94  *                        先度がそれより高くても，E_ILUSEエラーにならないこと
  95  *
  96  * 【テスト項目の実現方法】
  97  *
  98  *      (A-1)
  99  *              中優先度タスク（TASK1）に，高優先度上限ミューテックス（MTX2）を
 100  *              ロックさせ，高優先度になることを確認する．また，実行可能状態の
 101  *              高優先度タスク（TASK4）よりも，優先順位が高くなることを確認する．
 102  *              ディスパッチ禁止状態で実施する．
 103  *      (A-2)
 104  *              中優先度タスク（TASK1）に，中優先度上限ミューテックス（MTX1）を
 105  *              ロックさせ，優先度が変わらないことを確認する．また，実行可能状
 106  *              態の中優先度タスクを2つ（TASK2，TASK3）を用意しておき，優先順位
 107  *              が変わらないことを確認する．ディスパッチ禁止状態で実施する．
 108  *      (A-3)
 109  *              中優先度タスク（TASK1）が高優先度上限ミューテックス（MTX2）をロッ
 110  *              クして高優先度になっている状態で，中優先度上限ミューテックス
 111  *              （MTX1）をロックさせ，優先度が変わらないことを確認する．また，
 112  *              実行可能状態の高優先度タスクを2つ（TASK4，TASK5）を用意しておき，
 113  *              優先順位が変わらないことを確認する．ディスパッチ禁止状態で実施
 114  *              する．
 115  *      (B-1)
 116  *              中優先度タスク（TASK1）に高優先度上限ミューテックス（MTX2）のみ
 117  *              をロックさせている状態で，それをロック解除させ，中優先度になる
 118  *              ことを確認する．また，実行可能状態の中優先度タスク（TASK2）より
 119  *              も，優先順位が高くなることを確認する．
 120  *      (B-2)
 121  *              中優先度タスク（TASK1）に中優先度上限ミューテックス（MTX1）のみ
 122  *              をロックさせている状態で，それをロック解除させ，優先度が変わら
 123  *              ないことを確認する．また，実行可能状態の中優先度タスクを2つ
 124  *              （TASK2，TASK3）を用意しておき，優先順位が変わらないことを確認
 125  *              する．ディスパッチ禁止状態で実施する．
 126  *      (B-3)
 127  *              中優先度タスク（TASK1）に高優先度上限ミューテックス（MTX2）と中
 128  *              優先度上限ミューテックス（MTX1）をロックさせている状態で，中優
 129  *              先度上限ミューテックス（MTX1）をロック解除させ，優先度が変わら
 130  *              ないことを確認する．また，実行可能状態の高優先度タスクを2つ
 131  *              （TASK4，TASK5）を用意しておき，優先順位が変わらないことを確認
 132  *              する．ディスパッチ禁止状態で実施する．
 133  *      (C-1)
 134  *              中優先度タスク（TASK1）に高優先度上限ミューテックスを2つ（MTX2，
 135  *              MTX3）ロックさせ，別の中優先度タスク（TASK2）がMTX2を待っている
 136  *              状態で，TASK1にMTX2をロック解除させ，TASK2の優先度が高優先度に
 137  *              なることを確認する．また，TASK2の優先順位が，TASK1よりも低くな
 138  *              ることを確認する．
 139  *      (C-2)
 140  *              中優先度タスク（TASK2）に中優先度上限ミューテックス（MTX1）をロッ
 141  *              クさせ，別の中優先度タスク（TASK1）がMTX1を待っている状態で，
 142  *              TASK2にMTX1をロック解除させ，TASK1の優先度が中優先度のまま変化
 143  *              しないことを確認する．また，実行可能状態の中優先度タスクをもう
 144  *              1つ（TASK3）用意しておき，TASK1の優先順位がTASK3よりも低くなる
 145  *              ことを確認する．
 146  *      (C-3)
 147  *              中優先度タスク（TASK1）に中優先度上限ミューテックス（MTX1）と高
 148  *              優先度上限ミューテックス（MTX3）をロックさせ，別の中優先度タス
 149  *              ク（TASK2）が別の高優先度上限ミューテックス（MTX2）をロックして
 150  *              MTX1を待っている状態で，TASK1にMTX1をロック解除させ，TASK2の優
 151  *              先度が高優先度のまま変化しないことを確認する．また，TASK2の優先
 152  *              順位が，TASK1よりも低くなることを確認する．
 153  *      (D-1)
 154  *              高優先度タスク（TASK4）に，中優先度上限ミューテックス（MTX1）を
 155  *              ロックさせ，E_ILUSEエラーになることを確認する．
 156  *      (D-2)
 157  *              中優先度タスク（TASK1）が高優先度上限ミューテックス（MTX2）をロッ
 158  *              クして高優先度になっている状態で，中優先度上限ミューテックス
 159  *              （MTX1）をロックさせ，E_ILUSEエラーになるないことを確認する．
 160  *
 161  * 【使用リソース】
 162  *
 163  *      TASK1: 中優先度タスク，メインタスク，最初から起動
 164  *      TASK2: 中優先度タスク
 165  *      TASK3: 中優先度タスク
 166  *      TASK4: 高優先度タスク
 167  *      TASK5: 高優先度タスク
 168  *      MTX1: ミューテックス（TA_CEILING属性，上限は中優先度）
 169  *      MTX2: ミューテックス（TA_CEILING属性，上限は高優先度）
 170  *      MTX3: ミューテックス（TA_CEILING属性，上限は高優先度）
 171  *
 172  * 【テストシーケンス】
 173  *
 174  *      == TASK1（優先度：中）==
 175  *              call(set_bit_func(bit_mutex))
 176  *      1:      dis_dsp()
 177  *      2:      act_tsk(TASK2)
 178  *              act_tsk(TASK4)
 179  *      //              高：TASK4，中：TASK1→TASK2
 180  *      3:      ploc_mtx(MTX2)                                                          ... (A-1)
 181  *      //              高：TASK1→TASK4，中：TASK2，MTX2：TASK1
 182  *              get_pri(TSK_SELF, &tskpri)
 183  *              assert(tskpri == HIGH_PRIORITY)
 184  *      4:      ena_dsp()
 185  *      5:      unl_mtx(MTX2)                                                           ... (B-1)
 186  *      //              高：TASK4，中：TASK1→TASK2
 187  *      == TASK4（優先度：高）==
 188  *      6:      loc_mtx(MTX1) -> E_ILUSE                                        ... (D-1)
 189  *      7:      slp_tsk()
 190  *      //              中：TASK1→TASK2
 191  *      == TASK1（続き）==
 192  *      8:      get_pri(TSK_SELF, &tskpri)
 193  *              assert(tskpri == MID_PRIORITY)
 194  *
 195  *      9:      dis_dsp()
 196  *      10:     rot_rdq(MID_PRIORITY)
 197  *      //              中：TASK2→TASK1
 198  *      11:     act_tsk(TASK3)
 199  *      //              中：TASK2→TASK1→TASK3
 200  *      12:     ploc_mtx(MTX1)                                                          ... (A-2)
 201  *      //              中：TASK2→TASK1→TASK3，MTX1：TASK1
 202  *              get_pri(TSK_SELF, &tskpri)
 203  *              assert(tskpri == MID_PRIORITY)
 204  *      13:     ena_dsp()
 205  *      == TASK2（優先度：中）==
 206  *      14:     slp_tsk()
 207  *      //              中：TASK1→TASK3，MTX1：TASK1
 208  *      == TASK1（続き）==
 209  *      15:     slp_tsk()
 210  *      //              中：TASK3，MTX1：TASK1
 211  *      == TASK3（優先度：中）==
 212  *      16:     wup_tsk(TASK1)
 213  *      //              中：TASK3→TASK1，MTX1：TASK1
 214  *      17:     slp_tsk()
 215  *      //              中：TASK1，MTX1：TASK1
 216  *
 217  *      == TASK1（続き）==
 218  *      18:     wup_tsk(TASK2)
 219  *      //              中：TASK1→TASK2，MTX1：TASK1
 220  *      19:     dis_dsp()
 221  *      20:     rot_rdq(MID_PRIORITY)
 222  *      //              中：TASK2→TASK1，MTX1：TASK1
 223  *      21:     wup_tsk(TASK3)
 224  *      //              中：TASK2→TASK1→TASK3，MTX1：TASK1
 225  *      22:     unl_mtx(MTX1)                                                           ... (B-2)
 226  *      //              中：TASK2→TASK1→TASK3
 227  *              get_pri(TSK_SELF, &tskpri)
 228  *              assert(tskpri == MID_PRIORITY)
 229  *      23:     ena_dsp()
 230  *      == TASK2（優先度：中）==
 231  *      24:     slp_tsk()
 232  *      //              中：TASK1→TASK3
 233  *      == TASK1（続き）==
 234  *      25:     slp_tsk()
 235  *      //              中：TASK3
 236  *      == TASK3（優先度：中）==
 237  *      26:     wup_tsk(TASK1)
 238  *      //              中：TASK3→TASK1
 239  *      27:     slp_tsk()
 240  *      //              中：TASK1
 241  *
 242  *      == TASK1（続き）==
 243  *      28:     dis_dsp()
 244  *      29:     wup_tsk(TASK4)
 245  *      //              高：TASK4，中：TASK1
 246  *      30:     ploc_mtx(MTX2)
 247  *      //              高：TASK1→TASK4，MTX2：TASK1
 248  *      31:     rot_rdq(HIGH_PRIORITY)
 249  *      //              高：TASK4→TASK1，MTX2：TASK1
 250  *      32:     act_tsk(TASK5)
 251  *      //              高：TASK4→TASK1→TASK5，MTX2：TASK1
 252  *      33:     ploc_mtx(MTX1)                                                          ... (A-3)(D-2)
 253  *      //              高：TASK4→TASK1→TASK5，MTX2：TASK1，MTX1：TASK1
 254  *              get_pri(TSK_SELF, &tskpri)
 255  *              assert(tskpri == HIGH_PRIORITY)
 256  *      34:     ena_dsp()
 257  *      == TASK4（続き）==
 258  *      35:     slp_tsk()
 259  *      //              高：TASK1→TASK5，MTX2：TASK1，MTX1：TASK1
 260  *      == TASK1（続き）==
 261  *      36:     slp_tsk()
 262  *      //              高：TASK5，MTX2：TASK1，MTX1：TASK1
 263  *      == TASK5（優先度：高）==
 264  *      37:     wup_tsk(TASK1)
 265  *      //              高：TASK5→TASK1，MTX2：TASK1，MTX1：TASK1
 266  *      38:     slp_tsk()
 267  *      //              高：TASK1，MTX2：TASK1，MTX1：TASK1
 268  *
 269  *      == TASK1（続き）==
 270  *      39:     dis_dsp()
 271  *      40:     wup_tsk(TASK4)
 272  *      //              高：TASK1→TASK4，MTX2：TASK1，MTX1：TASK1
 273  *      41:     rot_rdq(HIGH_PRIORITY)
 274  *      //              高：TASK4→TASK1，MTX2：TASK1，MTX1：TASK1
 275  *      42:     wup_tsk(TASK5)
 276  *      //              高：TASK4→TASK1→TASK5，MTX2：TASK1，MTX1：TASK1
 277  *      43:     unl_mtx(MTX1)                                                           ... (B-3)
 278  *      //              高：TASK4→TASK1→TASK5，MTX2：TASK1
 279  *              get_pri(TSK_SELF, &tskpri)
 280  *              assert(tskpri == HIGH_PRIORITY)
 281  *      44:     ena_dsp()
 282  *      == TASK4（続き）==
 283  *      45:     slp_tsk()
 284  *      //              高：TASK1→TASK5，MTX2：TASK1
 285  *      == TASK1（続き）==
 286  *      46:     slp_tsk()
 287  *      //              高：TASK5，MTX2：TASK1
 288  *      == TASK5（続き）==
 289  *      47:     wup_tsk(TASK1)
 290  *      //              高：TASK5→TASK1，MTX2：TASK1
 291  *      48:     slp_tsk()
 292  *      //              高：TASK1，MTX2：TASK1
 293  *
 294  *      == TASK1（続き）==
 295  *      49:     wup_tsk(TASK2)
 296  *              wup_tsk(TASK3)
 297  *              slp_tsk()
 298  *      //              中：TASK2→TASK3，MTX2：TASK1
 299  *      == TASK2（続き）==
 300  *      50:     loc_mtx(MTX2)
 301  *      //              中：TASK3，MTX2：TASK1→TASK2
 302  *      == TASK3（続き）==
 303  *      51:     wup_tsk(TASK1)
 304  *      //              高：TASK1，中：TASK3，MTX2：TASK1→TASK2
 305  *      == TASK1（続き）==
 306  *      52:     loc_mtx(MTX3)
 307  *      //              高：TASK1，中：TASK3，MTX2：TASK1→TASK2，MTX3：TASK1
 308  *      53:     unl_mtx(MTX2)                                                           ... (C-1)
 309  *      //              高：TASK1→TASK2，中：TASK3，MTX2：TASK2，MTX3：TASK1
 310  *              get_pri(TASK2, &tskpri)
 311  *              assert(tskpri == HIGH_PRIORITY)
 312  *      54:     loc_mtx(MTX1)
 313  *      //              高：TASK1→TASK2，中：TASK3，MTX1：TASK1，MTX2：TASK2，MTX3：TASK1
 314  *      55:     slp_tsk()
 315  *      //              高：TASK2，中：TASK3，MTX1：TASK1，MTX2：TASK2，MTX3：TASK1
 316  *
 317  *      == TASK2（続き）==
 318  *      56:     wup_tsk(TASK1)
 319  *      //              高：TASK2→TASK1，中：TASK3，MTX1：TASK1，MTX2：TASK2，MTX3：TASK1
 320  *      57:     loc_mtx(MTX1)
 321  *      //              高：TASK1，中：TASK3，MTX1：TASK1→TASK2，MTX2：TASK2，MTX3：TASK1
 322  *      == TASK1（続き）==
 323  *      58:     unl_mtx(MTX1)                                                           ... (C-3)
 324  *      //              高：TASK1→TASK2，中：TASK3，MTX1：TASK2，MTX2：TASK2，MTX3：TASK1
 325  *              get_pri(TASK2, &tskpri)
 326  *              assert(tskpri == HIGH_PRIORITY)
 327  *      59:     unl_mtx(MTX3)
 328  *      //              高：TASK2，中：TASK1→TASK3，MTX1：TASK2，MTX2：TASK2
 329  *      == TASK2（続き）==
 330  *      60:     unl_mtx(MTX2)
 331  *      //              中：TASK2→TASK1→TASK3，MTX1：TASK2
 332  *
 333  *      61:     rot_rdq(MID_PRIORITY)
 334  *      //              中：TASK1→TASK3→TASK2，MTX1：TASK2
 335  *      == TASK1（続き）==
 336  *      62:     loc_mtx(MTX1)
 337  *      //              中：TASK3→TASK2，MTX1：TASK2→TASK1
 338  *      == TASK3（続き）==
 339  *      63:     rot_rdq(MID_PRIORITY)
 340  *      //              中：TASK2→TASK3，MTX1：TASK2→TASK1
 341  *      == TASK2（続き）==
 342  *      64:     unl_mtx(MTX1)                                                           ... (C-2)
 343  *      //              中：TASK2→TASK3→TASK1，MTX1：TASK1
 344  *              get_pri(TASK1, &tskpri)
 345  *              assert(tskpri == MID_PRIORITY)
 346  *      == TASK2（続き）==
 347  *      65:     ext_tsk() -> noreturn
 348  *      //              中：TASK3→TASK1，MTX1：TASK1
 349  *      == TASK3（続き）==
 350  *      66:     ext_tsk() -> noreturn
 351  *      //              中：TASK1，MTX1：TASK1
 352  *      == TASK1（続き）==
 353  *      67:     END
 354  */
 355
 356 #include <kernel.h>
 357 #include <t_syslog.h>
 358 #include "syssvc/logtask.h"
 359 #include "kernel_cfg.h"
 360 #include "test_lib.h"
 361 #include "test_mutex4.h"
 362
 363 extern ER       bit_mutex(void);
 364
 365 void
 366 task1(intptr_t exinf)
 367 {
 368         ER              ercd;
 369         PRI             tskpri;
 370
 371         set_bit_func(bit_mutex);
 372
 373         check_point(1);
 374         ercd = dis_dsp();
 375         check_ercd(ercd, E_OK);
 376
 377         check_point(2);
 378         ercd = act_tsk(TASK2);
 379         check_ercd(ercd, E_OK);
 380
 381         ercd = act_tsk(TASK4);
 382         check_ercd(ercd, E_OK);
 383
 384         check_point(3);
 385         ercd = ploc_mtx(MTX2);
 386         check_ercd(ercd, E_OK);
 387
 388         ercd = get_pri(TSK_SELF, &tskpri);
 389         check_ercd(ercd, E_OK);
 390         check_assert(tskpri == HIGH_PRIORITY);
 391
 392         check_point(4);
 393         ercd = ena_dsp();
 394         check_ercd(ercd, E_OK);
 395
 396         check_point(5);
 397         ercd = unl_mtx(MTX2);
 398         check_ercd(ercd, E_OK);
 399
 400         check_point(8);
 401         ercd = get_pri(TSK_SELF, &tskpri);
 402         check_ercd(ercd, E_OK);
 403         check_assert(tskpri == MID_PRIORITY);
 404
 405         check_point(9);
 406         ercd = dis_dsp();
 407         check_ercd(ercd, E_OK);
 408
 409         check_point(10);
 410         ercd = rot_rdq(MID_PRIORITY);
 411         check_ercd(ercd, E_OK);
 412
 413         check_point(11);
 414         ercd = act_tsk(TASK3);
 415         check_ercd(ercd, E_OK);
 416
 417         check_point(12);
 418         ercd = ploc_mtx(MTX1);
 419         check_ercd(ercd, E_OK);
 420
 421         ercd = get_pri(TSK_SELF, &tskpri);
 422         check_ercd(ercd, E_OK);
 423         check_assert(tskpri == MID_PRIORITY);
 424
 425         check_point(13);
 426         ercd = ena_dsp();
 427         check_ercd(ercd, E_OK);
 428
 429         check_point(15);
 430         ercd = slp_tsk();
 431         check_ercd(ercd, E_OK);
 432
 433         check_point(18);
 434         ercd = wup_tsk(TASK2);
 435         check_ercd(ercd, E_OK);
 436
 437         check_point(19);
 438         ercd = dis_dsp();
 439         check_ercd(ercd, E_OK);
 440
 441         check_point(20);
 442         ercd = rot_rdq(MID_PRIORITY);
 443         check_ercd(ercd, E_OK);
 444
 445         check_point(21);
 446         ercd = wup_tsk(TASK3);
 447         check_ercd(ercd, E_OK);
 448
 449         check_point(22);
 450         ercd = unl_mtx(MTX1);
 451         check_ercd(ercd, E_OK);
 452
 453         ercd = get_pri(TSK_SELF, &tskpri);
 454         check_ercd(ercd, E_OK);
 455         check_assert(tskpri == MID_PRIORITY);
 456
 457         check_point(23);
 458         ercd = ena_dsp();
 459         check_ercd(ercd, E_OK);
 460
 461         check_point(25);
 462         ercd = slp_tsk();
 463         check_ercd(ercd, E_OK);
 464
 465         check_point(28);
 466         ercd = dis_dsp();
 467         check_ercd(ercd, E_OK);
 468
 469         check_point(29);
 470         ercd = wup_tsk(TASK4);
 471         check_ercd(ercd, E_OK);
 472
 473         check_point(30);
 474         ercd = ploc_mtx(MTX2);
 475         check_ercd(ercd, E_OK);
 476
 477         check_point(31);
 478         ercd = rot_rdq(HIGH_PRIORITY);
 479         check_ercd(ercd, E_OK);
 480
 481         check_point(32);
 482         ercd = act_tsk(TASK5);
 483         check_ercd(ercd, E_OK);
 484
 485         check_point(33);
 486         ercd = ploc_mtx(MTX1);
 487         check_ercd(ercd, E_OK);
 488
 489         ercd = get_pri(TSK_SELF, &tskpri);
 490         check_ercd(ercd, E_OK);
 491         check_assert(tskpri == HIGH_PRIORITY);
 492
 493         check_point(34);
 494         ercd = ena_dsp();
 495         check_ercd(ercd, E_OK);
 496
 497         check_point(36);
 498         ercd = slp_tsk();
 499         check_ercd(ercd, E_OK);
 500
 501         check_point(39);
 502         ercd = dis_dsp();
 503         check_ercd(ercd, E_OK);
 504
 505         check_point(40);
 506         ercd = wup_tsk(TASK4);
 507         check_ercd(ercd, E_OK);
 508
 509         check_point(41);
 510         ercd = rot_rdq(HIGH_PRIORITY);
 511         check_ercd(ercd, E_OK);
 512
 513         check_point(42);
 514         ercd = wup_tsk(TASK5);
 515         check_ercd(ercd, E_OK);
 516
 517         check_point(43);
 518         ercd = unl_mtx(MTX1);
 519         check_ercd(ercd, E_OK);
 520
 521         ercd = get_pri(TSK_SELF, &tskpri);
 522         check_ercd(ercd, E_OK);
 523         check_assert(tskpri == HIGH_PRIORITY);
 524
 525         check_point(44);
 526         ercd = ena_dsp();
 527         check_ercd(ercd, E_OK);
 528
 529         check_point(46);
 530         ercd = slp_tsk();
 531         check_ercd(ercd, E_OK);
 532
 533         check_point(49);
 534         ercd = wup_tsk(TASK2);
 535         check_ercd(ercd, E_OK);
 536
 537         ercd = wup_tsk(TASK3);
 538         check_ercd(ercd, E_OK);
 539
 540         ercd = slp_tsk();
 541         check_ercd(ercd, E_OK);
 542
 543         check_point(52);
 544         ercd = loc_mtx(MTX3);
 545         check_ercd(ercd, E_OK);
 546
 547         check_point(53);
 548         ercd = unl_mtx(MTX2);
 549         check_ercd(ercd, E_OK);
 550
 551         ercd = get_pri(TASK2, &tskpri);
 552         check_ercd(ercd, E_OK);
 553         check_assert(tskpri == HIGH_PRIORITY);
 554
 555         check_point(54);
 556         ercd = loc_mtx(MTX1);
 557         check_ercd(ercd, E_OK);
 558
 559         check_point(55);
 560         ercd = slp_tsk();
 561         check_ercd(ercd, E_OK);
 562
 563         check_point(58);
 564         ercd = unl_mtx(MTX1);
 565         check_ercd(ercd, E_OK);
 566
 567         ercd = get_pri(TASK2, &tskpri);
 568         check_ercd(ercd, E_OK);
 569         check_assert(tskpri == HIGH_PRIORITY);
 570
 571         check_point(59);
 572         ercd = unl_mtx(MTX3);
 573         check_ercd(ercd, E_OK);
 574
 575         check_point(62);
 576         ercd = loc_mtx(MTX1);
 577         check_ercd(ercd, E_OK);
 578
 579         check_finish(67);
 580
 581         check_point(0);
 582 }
 583
 584 void
 585 task2(intptr_t exinf)
 586 {
 587         ER              ercd;
 588         PRI             tskpri;
 589
 590         check_point(14);
 591         ercd = slp_tsk();
 592         check_ercd(ercd, E_OK);
 593
 594         check_point(24);
 595         ercd = slp_tsk();
 596         check_ercd(ercd, E_OK);
 597
 598         check_point(50);
 599         ercd = loc_mtx(MTX2);
 600         check_ercd(ercd, E_OK);
 601
 602         check_point(56);
 603         ercd = wup_tsk(TASK1);
 604         check_ercd(ercd, E_OK);
 605
 606         check_point(57);
 607         ercd = loc_mtx(MTX1);
 608         check_ercd(ercd, E_OK);
 609
 610         check_point(60);
 611         ercd = unl_mtx(MTX2);
 612         check_ercd(ercd, E_OK);
 613
 614         check_point(61);
 615         ercd = rot_rdq(MID_PRIORITY);
 616         check_ercd(ercd, E_OK);
 617
 618         check_point(64);
 619         ercd = unl_mtx(MTX1);
 620         check_ercd(ercd, E_OK);
 621
 622         ercd = get_pri(TASK1, &tskpri);
 623         check_ercd(ercd, E_OK);
 624         check_assert(tskpri == MID_PRIORITY);
 625
 626         check_point(65);
 627         ercd = ext_tsk();
 628
 629         check_point(0);
 630 }
 631
 632 void
 633 task3(intptr_t exinf)
 634 {
 635         ER              ercd;
 636
 637         check_point(16);
 638         ercd = wup_tsk(TASK1);
 639         check_ercd(ercd, E_OK);
 640
 641         check_point(17);
 642         ercd = slp_tsk();
 643         check_ercd(ercd, E_OK);
 644
 645         check_point(26);
 646         ercd = wup_tsk(TASK1);
 647         check_ercd(ercd, E_OK);
 648
 649         check_point(27);
 650         ercd = slp_tsk();
 651         check_ercd(ercd, E_OK);
 652
 653         check_point(51);
 654         ercd = wup_tsk(TASK1);
 655         check_ercd(ercd, E_OK);
 656
 657         check_point(63);
 658         ercd = rot_rdq(MID_PRIORITY);
 659         check_ercd(ercd, E_OK);
 660
 661         check_point(66);
 662         ercd = ext_tsk();
 663
 664         check_point(0);
 665 }
 666
 667 void
 668 task4(intptr_t exinf)
 669 {
 670         ER              ercd;
 671
 672         check_point(6);
 673         ercd = loc_mtx(MTX1);
 674         check_ercd(ercd, E_ILUSE);
 675
 676         check_point(7);
 677         ercd = slp_tsk();
 678         check_ercd(ercd, E_OK);
 679
 680         check_point(35);
 681         ercd = slp_tsk();
 682         check_ercd(ercd, E_OK);
 683
 684         check_point(45);
 685         ercd = slp_tsk();
 686         check_ercd(ercd, E_OK);
 687
 688         check_point(0);
 689 }
 690
 691 void
 692 task5(intptr_t exinf)
 693 {
 694         ER              ercd;
 695
 696         check_point(37);
 697         ercd = wup_tsk(TASK1);
 698         check_ercd(ercd, E_OK);
 699
 700         check_point(38);
 701         ercd = slp_tsk();
 702         check_ercd(ercd, E_OK);
 703
 704         check_point(47);
 705         ercd = wup_tsk(TASK1);
 706         check_ercd(ercd, E_OK);
 707
 708         check_point(48);
 709         ercd = slp_tsk();
 710         check_ercd(ercd, E_OK);
 711
 712         check_point(0);
 713 }