asp/extension/mutex/test/test_mutex7.c

   1 /*
   2  *  TOPPERS Software
   3  *      Toyohashi Open Platform for Embedded Real-Time Systems
   4  *
   5  *  Copyright (C) 2008-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_mutex7.c 1696 2010-01-01 16:01:25Z ertl-hiro $
  38  */
  39
  40 /*
  41  *              ミューテックスのテスト(7)
  42  *
  43  * 【テストの目的】
  44  *
  45  *  優先度上限ミューテックスに対して，タスクの強制終了時のミューテック
  46  *  ス関連の処理を網羅的にテストする．
  47  *
  48  * 【テスト項目】
  49  *
  50  *      (A) タスクの強制終了時（ter_tsk）
  51  *              (A-1) ロックしていたミューテックス（1つ）がロック解除されること．
  52  *              (A-2) ロックしていたミューテックス（1つ）がロック解除され，ロッ
  53  *                        クを待っていたタスクがそれをロックし，優先度が変化し，待
  54  *                        ち解除されること．
  55  *              (A-3) (A-2)の結果，タスクディスパッチが起こること．
  56  *              (A-4) ロックしていたミューテックス（複数）がすべてロック解除さ
  57  *                        れること．
  58  *              (A-5) ロックしていたミューテックス（複数）がロック解除され，ロッ
  59  *                        クを待っていたタスク（複数）がそれをロックし，優先度が変
  60  *                        化し，待ち解除されること．その時に，後でミューテックスを
  61  *                        ロックしたタスク（先にロックしていたミューテックスを待っ
  62  *                        ていたタスク）の方が，優先順位が高くなること．
  63  *              (A-6) (A-5)の結果，タスクディスパッチが起こること．
  64  *
  65  * 【テスト項目の実現方法】
  66  *
  67  *      (A-1)
  68  *              低優先度タスク（TASK2）にミューテックス（MTX1）をロックさせ，別
  69  *              のタスク（TASK1）からTASK2をter_tskすると，ロックが解除されるこ
  70  *              とを確認する．
  71  *      (A-2)
  72  *              低優先度タスク（TASK2）に中優先度上限ミューテックス（MTX1）をロッ
  73  *              クさせ，別の低優先度タスク（TASK3）にMTX1を待たせた状態で，高優
  74  *              先度タスク（TASK1）からTASK2をter_tskすると，TASK3が中優先度に
  75  *              なって待ち解除されることを確認する．
  76  *      (A-3)
  77  *              低優先度タスク（TASK2）に中優先度上限ミューテックス（MTX1）をロッ
  78  *              クさせ，別の低優先度タスク（TASK3）にMTX1を待たせた状態で，別の
  79  *              低優先度タスク（TASK1）からTASK2をter_tskすると，TASK3が中優先
  80  *              度になって待ち解除され，TASK3に切り換わることを確認する．
  81  *      (A-4)
  82  *              低優先度タスク（TASK2）にミューテックスを2つ（MTX1，MTX2）ロッ
  83  *              クさせ，別のタスク（TASK1）からTASK2をter_tskすると，両方のロッ
  84  *              クが解除されることを確認する．
  85  *      (A-5)
  86  *              低優先度タスク（TASK2）に高優先度上限ミューテックス2つ（MTX1，
  87  *              MTX2）をこの順でロックさせ，別の低優先度タスク2つ（TASK3，
  88  *              TASK4）にそれぞれのロックを待たせた状態で，高優先度タスク
  89  *              （TASK1）からTASK2をter_tskすると，TASK3とTASK4が中優先度になっ
  90  *              て待ち解除されることを確認する．また，先にロックしていたミュー
  91  *              テックス（MTX1）を待っていたタスク（TASK3）が，TASK4よりも優先
  92  *              順位が高くなることを確認する．
  93  *      (A-6)
  94  *              低優先度タスク（TASK2）に高優先度上限ミューテックス2つ（MTX1，
  95  *              MTX2）をこの順でロックさせ，別の低優先度タスク2つ（TASK3，
  96  *              TASK4）にそれぞれのロックを待たせた状態で，別の低優先度タスク
  97  *              （TASK1）からTASK2 をter_tskすると，TASK3とTASK4が中優先度になっ
  98  *              て待ち解除され，TASK3に切り換わることを確認する．
  99  *
 100  * 【使用リソース】
 101  *
 102  *      TASK1: 高優先度タスク，メインタスク，最初から起動
 103  *      TASK2: 低優先度タスク
 104  *      TASK3: 低優先度タスク
 105  *      TASK4: 低優先度タスク
 106  *      MTX1: ミューテックス（TA_CEILING属性，上限は中優先度）
 107  *      MTX2: ミューテックス（TA_CEILING属性，上限は中優先度）
 108  *
 109  * 【テストシーケンス】
 110  *
 111  *      == TASK1（優先度：高）==
 112  *              call(set_bit_func(bit_mutex))
 113  *      1:      act_tsk(TASK2)
 114  *      2:      slp_tsk()
 115  *      == TASK2-1（優先度：低）==
 116  *      3:      loc_mtx(MTX1)
 117  *      4:      wup_tsk(TASK1)
 118  *      == TASK1（続き）==
 119  *      5:      ter_tsk(TASK2)                  ... (A-1)
 120  *      6:      ref_mtx(MTX1, &rmtx)
 121  *              assert(rmtx.htskid == TSK_NONE)
 122  *              assert(rmtx.wtskid == TSK_NONE)
 123  *
 124  *      7:      act_tsk(TASK2)
 125  *              act_tsk(TASK3)
 126  *      8:      slp_tsk()
 127  *      == TASK2-2（優先度：低）==
 128  *      9:      loc_mtx(MTX1)
 129  *      10:     tslp_tsk(10) -> E_TMOUT
 130  *      == TASK3-1（優先度：低）==
 131  *      11:     loc_mtx(MTX1)
 132  *      == TASK2-2（続き）==
 133  *      12:     wup_tsk(TASK1)
 134  *      == TASK1（続き）==
 135  *      13:     ter_tsk(TASK2)                  ... (A-2)
 136  *      14:     ref_mtx(MTX1, &rmtx)
 137  *              assert(rmtx.htskid == TASK3)
 138  *              assert(rmtx.wtskid == TSK_NONE)
 139  *              get_pri(TASK3, &tskpri)
 140  *              assert(tskpri == MID_PRIORITY)
 141  *      15:     ter_tsk(TASK3)
 142  *
 143  *      16:     act_tsk(TASK2)
 144  *              act_tsk(TASK3)
 145  *      17:     chg_pri(TSK_SELF, LOW_PRIORITY)
 146  *      == TASK2-3（優先度：低）==
 147  *      18:     loc_mtx(MTX1)
 148  *      19:     slp_tsk()
 149  *      == TASK3-2（優先度：低）==
 150  *      20:     loc_mtx(MTX1)
 151  *      == TASK1（続き）==
 152  *      21:     ter_tsk(TASK2)                  ... (A-3)
 153  *      == TASK3-2（続き）==
 154  *      22:     ref_mtx(MTX1, &rmtx)
 155  *              assert(rmtx.htskid == TASK3)
 156  *              assert(rmtx.wtskid == TSK_NONE)
 157  *              get_pri(TASK3, &tskpri)
 158  *              assert(tskpri == MID_PRIORITY)
 159  *      23:     ext_tsk() -> noreturn
 160  *      == TASK1（続き）==
 161  *      24:     chg_pri(TSK_SELF, HIGH_PRIORITY)
 162  *
 163  *      25:     act_tsk(TASK2)
 164  *      26:     slp_tsk()
 165  *      == TASK2-4（優先度：低）==
 166  *      27:     loc_mtx(MTX1)
 167  *              loc_mtx(MTX2)
 168  *      28:     wup_tsk(TASK1)
 169  *      == TASK1（続き）==
 170  *      29:     ter_tsk(TASK2)                  ... (A-4)
 171  *      30:     ref_mtx(MTX1, &rmtx)
 172  *              assert(rmtx.htskid == TSK_NONE)
 173  *              assert(rmtx.wtskid == TSK_NONE)
 174  *              ref_mtx(MTX2, &rmtx)
 175  *              assert(rmtx.htskid == TSK_NONE)
 176  *              assert(rmtx.wtskid == TSK_NONE)
 177  *      31:     MISSING
 178  *
 179  *      32:     act_tsk(TASK2)
 180  *              act_tsk(TASK3)
 181  *              act_tsk(TASK4)
 182  *      33:     slp_tsk()
 183  *      == TASK2-5（優先度：低）==
 184  *      34:     loc_mtx(MTX1)
 185  *              loc_mtx(MTX2)
 186  *      35:     tslp_tsk(10) -> E_TMOUT
 187  *      == TASK3-3（優先度：低）==
 188  *      36:     loc_mtx(MTX1)
 189  *      == TASK4-1（優先度：低）==
 190  *      37:     loc_mtx(MTX2)
 191  *      == TASK2-5（続き）==
 192  *      38:     wup_tsk(TASK1)
 193  *      == TASK1（続き）==
 194  *      39:     ter_tsk(TASK2)                  ... (A-5)
 195  *      40:     ref_mtx(MTX1, &rmtx)
 196  *              assert(rmtx.htskid == TASK3)
 197  *              assert(rmtx.wtskid == TSK_NONE)
 198  *              ref_mtx(MTX2, &rmtx)
 199  *              assert(rmtx.htskid == TASK4)
 200  *              assert(rmtx.wtskid == TSK_NONE)
 201  *              get_pri(TASK3, &tskpri)
 202  *              assert(tskpri == MID_PRIORITY)
 203  *              get_pri(TASK4, &tskpri)
 204  *              assert(tskpri == MID_PRIORITY)
 205  *      41:     chg_pri(TSK_SELF, LOW_PRIORITY)
 206  *      == TASK3-3（続き）==
 207  *      42:     ext_tsk() -> noreturn
 208  *      == TASK4-1（続き）==
 209  *      43:     ext_tsk() -> noreturn
 210  *      == TASK1（続き）==
 211  *      44:     act_tsk(TASK2)
 212  *              act_tsk(TASK3)
 213  *              act_tsk(TASK4)
 214  *      45:     chg_pri(TSK_SELF, LOW_PRIORITY)
 215  *      == TASK2-6（優先度：低）==
 216  *      46:     loc_mtx(MTX1)
 217  *              loc_mtx(MTX2)
 218  *      47:     slp_tsk()
 219  *      == TASK3-4（優先度：低）==
 220  *      48:     loc_mtx(MTX1)
 221  *      == TASK4-2（優先度：低）==
 222  *      49:     loc_mtx(MTX2)
 223  *      == TASK1（続き）==
 224  *      50:     ter_tsk(TASK2)                  ... (A-6)
 225  *      == TASK3-4（続き）==
 226  *      51:     ref_mtx(MTX1, &rmtx)
 227  *              assert(rmtx.htskid == TASK3)
 228  *              assert(rmtx.wtskid == TSK_NONE)
 229  *              ref_mtx(MTX2, &rmtx)
 230  *              assert(rmtx.htskid == TASK4)
 231  *              assert(rmtx.wtskid == TSK_NONE)
 232  *              get_pri(TASK3, &tskpri)
 233  *              assert(tskpri == MID_PRIORITY)
 234  *              get_pri(TASK4, &tskpri)
 235  *              assert(tskpri == MID_PRIORITY)
 236  *      52:     ext_tsk() -> noreturn
 237  *      == TASK4-2（続き）==
 238  *      53:     ext_tsk() -> noreturn
 239  *      == TASK1（続き）==
 240  *      54:     END
 241  */
 242
 243 #include <kernel.h>
 244 #include <t_syslog.h>
 245 #include "syssvc/logtask.h"
 246 #include "kernel_cfg.h"
 247 #include "test_lib.h"
 248 #include "test_mutex7.h"
 249
 250 extern ER       bit_mutex(void);
 251
 252 void
 253 task1(intptr_t exinf)
 254 {
 255         ER              ercd;
 256         PRI             tskpri;
 257         T_RMTX  rmtx;
 258
 259         set_bit_func(bit_mutex);
 260
 261         check_point(1);
 262         ercd = act_tsk(TASK2);
 263         check_ercd(ercd, E_OK);
 264
 265         check_point(2);
 266         ercd = slp_tsk();
 267         check_ercd(ercd, E_OK);
 268
 269         check_point(5);
 270         ercd = ter_tsk(TASK2);
 271         check_ercd(ercd, E_OK);
 272
 273         check_point(6);
 274         ercd = ref_mtx(MTX1, &rmtx);
 275         check_ercd(ercd, E_OK);
 276         check_assert(rmtx.htskid == TSK_NONE);
 277         check_assert(rmtx.wtskid == TSK_NONE);
 278
 279         check_point(7);
 280         ercd = act_tsk(TASK2);
 281         check_ercd(ercd, E_OK);
 282
 283         ercd = act_tsk(TASK3);
 284         check_ercd(ercd, E_OK);
 285
 286         check_point(8);
 287         ercd = slp_tsk();
 288         check_ercd(ercd, E_OK);
 289
 290         check_point(13);
 291         ercd = ter_tsk(TASK2);
 292         check_ercd(ercd, E_OK);
 293
 294         check_point(14);
 295         ercd = ref_mtx(MTX1, &rmtx);
 296         check_ercd(ercd, E_OK);
 297         check_assert(rmtx.htskid == TASK3);
 298         check_assert(rmtx.wtskid == TSK_NONE);
 299
 300         ercd = get_pri(TASK3, &tskpri);
 301         check_ercd(ercd, E_OK);
 302         check_assert(tskpri == MID_PRIORITY);
 303
 304         check_point(15);
 305         ercd = ter_tsk(TASK3);
 306         check_ercd(ercd, E_OK);
 307
 308         check_point(16);
 309         ercd = act_tsk(TASK2);
 310         check_ercd(ercd, E_OK);
 311
 312         ercd = act_tsk(TASK3);
 313         check_ercd(ercd, E_OK);
 314
 315         check_point(17);
 316         ercd = chg_pri(TSK_SELF, LOW_PRIORITY);
 317         check_ercd(ercd, E_OK);
 318
 319         check_point(21);
 320         ercd = ter_tsk(TASK2);
 321         check_ercd(ercd, E_OK);
 322
 323         check_point(24);
 324         ercd = chg_pri(TSK_SELF, HIGH_PRIORITY);
 325         check_ercd(ercd, E_OK);
 326
 327         check_point(25);
 328         ercd = act_tsk(TASK2);
 329         check_ercd(ercd, E_OK);
 330
 331         check_point(26);
 332         ercd = slp_tsk();
 333         check_ercd(ercd, E_OK);
 334
 335         check_point(29);
 336         ercd = ter_tsk(TASK2);
 337         check_ercd(ercd, E_OK);
 338
 339         check_point(30);
 340         ercd = ref_mtx(MTX1, &rmtx);
 341         check_ercd(ercd, E_OK);
 342         check_assert(rmtx.htskid == TSK_NONE);
 343         check_assert(rmtx.wtskid == TSK_NONE);
 344
 345         ercd = ref_mtx(MTX2, &rmtx);
 346         check_ercd(ercd, E_OK);
 347         check_assert(rmtx.htskid == TSK_NONE);
 348         check_assert(rmtx.wtskid == TSK_NONE);
 349
 350         check_point(31);
 351
 352         check_point(32);
 353         ercd = act_tsk(TASK2);
 354         check_ercd(ercd, E_OK);
 355
 356         ercd = act_tsk(TASK3);
 357         check_ercd(ercd, E_OK);
 358
 359         ercd = act_tsk(TASK4);
 360         check_ercd(ercd, E_OK);
 361
 362         check_point(33);
 363         ercd = slp_tsk();
 364         check_ercd(ercd, E_OK);
 365
 366         check_point(39);
 367         ercd = ter_tsk(TASK2);
 368         check_ercd(ercd, E_OK);
 369
 370         check_point(40);
 371         ercd = ref_mtx(MTX1, &rmtx);
 372         check_ercd(ercd, E_OK);
 373         check_assert(rmtx.htskid == TASK3);
 374         check_assert(rmtx.wtskid == TSK_NONE);
 375
 376         ercd = ref_mtx(MTX2, &rmtx);
 377         check_ercd(ercd, E_OK);
 378         check_assert(rmtx.htskid == TASK4);
 379         check_assert(rmtx.wtskid == TSK_NONE);
 380
 381         ercd = get_pri(TASK3, &tskpri);
 382         check_ercd(ercd, E_OK);
 383         check_assert(tskpri == MID_PRIORITY);
 384
 385         ercd = get_pri(TASK4, &tskpri);
 386         check_ercd(ercd, E_OK);
 387         check_assert(tskpri == MID_PRIORITY);
 388
 389         check_point(41);
 390         ercd = chg_pri(TSK_SELF, LOW_PRIORITY);
 391         check_ercd(ercd, E_OK);
 392
 393         check_point(44);
 394         ercd = act_tsk(TASK2);
 395         check_ercd(ercd, E_OK);
 396
 397         ercd = act_tsk(TASK3);
 398         check_ercd(ercd, E_OK);
 399
 400         ercd = act_tsk(TASK4);
 401         check_ercd(ercd, E_OK);
 402
 403         check_point(45);
 404         ercd = chg_pri(TSK_SELF, LOW_PRIORITY);
 405         check_ercd(ercd, E_OK);
 406
 407         check_point(50);
 408         ercd = ter_tsk(TASK2);
 409         check_ercd(ercd, E_OK);
 410
 411         check_finish(54);
 412
 413         check_point(0);
 414 }
 415
 416 static uint_t   task2_count = 0;
 417
 418 void
 419 task2(intptr_t exinf)
 420 {
 421         ER              ercd;
 422
 423         switch (++task2_count) {
 424         case 1:
 425                 check_point(3);
 426                 ercd = loc_mtx(MTX1);
 427                 check_ercd(ercd, E_OK);
 428
 429                 check_point(4);
 430                 ercd = wup_tsk(TASK1);
 431                 check_ercd(ercd, E_OK);
 432
 433                 check_point(0);
 434
 435         case 2:
 436                 check_point(9);
 437                 ercd = loc_mtx(MTX1);
 438                 check_ercd(ercd, E_OK);
 439
 440                 check_point(10);
 441                 ercd = tslp_tsk(10);
 442                 check_ercd(ercd, E_TMOUT);
 443
 444                 check_point(12);
 445                 ercd = wup_tsk(TASK1);
 446                 check_ercd(ercd, E_OK);
 447
 448                 check_point(0);
 449
 450         case 3:
 451                 check_point(18);
 452                 ercd = loc_mtx(MTX1);
 453                 check_ercd(ercd, E_OK);
 454
 455                 check_point(19);
 456                 ercd = slp_tsk();
 457                 check_ercd(ercd, E_OK);
 458
 459                 check_point(0);
 460
 461         case 4:
 462                 check_point(27);
 463                 ercd = loc_mtx(MTX1);
 464                 check_ercd(ercd, E_OK);
 465
 466                 ercd = loc_mtx(MTX2);
 467                 check_ercd(ercd, E_OK);
 468
 469                 check_point(28);
 470                 ercd = wup_tsk(TASK1);
 471                 check_ercd(ercd, E_OK);
 472
 473                 check_point(0);
 474
 475         case 5:
 476                 check_point(34);
 477                 ercd = loc_mtx(MTX1);
 478                 check_ercd(ercd, E_OK);
 479
 480                 ercd = loc_mtx(MTX2);
 481                 check_ercd(ercd, E_OK);
 482
 483                 check_point(35);
 484                 ercd = tslp_tsk(10);
 485                 check_ercd(ercd, E_TMOUT);
 486
 487                 check_point(38);
 488                 ercd = wup_tsk(TASK1);
 489                 check_ercd(ercd, E_OK);
 490
 491                 check_point(0);
 492
 493         case 6:
 494                 check_point(46);
 495                 ercd = loc_mtx(MTX1);
 496                 check_ercd(ercd, E_OK);
 497
 498                 ercd = loc_mtx(MTX2);
 499                 check_ercd(ercd, E_OK);
 500
 501                 check_point(47);
 502                 ercd = slp_tsk();
 503                 check_ercd(ercd, E_OK);
 504
 505                 check_point(0);
 506         }
 507         check_point(0);
 508 }
 509
 510 static uint_t   task3_count = 0;
 511
 512 void
 513 task3(intptr_t exinf)
 514 {
 515         ER              ercd;
 516         PRI             tskpri;
 517         T_RMTX  rmtx;
 518
 519         switch (++task3_count) {
 520         case 1:
 521                 check_point(11);
 522                 ercd = loc_mtx(MTX1);
 523                 check_ercd(ercd, E_OK);
 524
 525                 check_point(0);
 526
 527         case 2:
 528                 check_point(20);
 529                 ercd = loc_mtx(MTX1);
 530                 check_ercd(ercd, E_OK);
 531
 532                 check_point(22);
 533                 ercd = ref_mtx(MTX1, &rmtx);
 534                 check_ercd(ercd, E_OK);
 535                 check_assert(rmtx.htskid == TASK3);
 536                 check_assert(rmtx.wtskid == TSK_NONE);
 537
 538                 ercd = get_pri(TASK3, &tskpri);
 539                 check_ercd(ercd, E_OK);
 540                 check_assert(tskpri == MID_PRIORITY);
 541
 542                 check_point(23);
 543                 ercd = ext_tsk();
 544
 545                 check_point(0);
 546
 547         case 3:
 548                 check_point(36);
 549                 ercd = loc_mtx(MTX1);
 550                 check_ercd(ercd, E_OK);
 551
 552                 check_point(42);
 553                 ercd = ext_tsk();
 554
 555                 check_point(0);
 556
 557         case 4:
 558                 check_point(48);
 559                 ercd = loc_mtx(MTX1);
 560                 check_ercd(ercd, E_OK);
 561
 562                 check_point(51);
 563                 ercd = ref_mtx(MTX1, &rmtx);
 564                 check_ercd(ercd, E_OK);
 565                 check_assert(rmtx.htskid == TASK3);
 566                 check_assert(rmtx.wtskid == TSK_NONE);
 567
 568                 ercd = ref_mtx(MTX2, &rmtx);
 569                 check_ercd(ercd, E_OK);
 570                 check_assert(rmtx.htskid == TASK4);
 571                 check_assert(rmtx.wtskid == TSK_NONE);
 572
 573                 ercd = get_pri(TASK3, &tskpri);
 574                 check_ercd(ercd, E_OK);
 575                 check_assert(tskpri == MID_PRIORITY);
 576
 577                 ercd = get_pri(TASK4, &tskpri);
 578                 check_ercd(ercd, E_OK);
 579                 check_assert(tskpri == MID_PRIORITY);
 580
 581                 check_point(52);
 582                 ercd = ext_tsk();
 583
 584                 check_point(0);
 585         }
 586         check_point(0);
 587 }
 588
 589 static uint_t   task4_count = 0;
 590
 591 void
 592 task4(intptr_t exinf)
 593 {
 594         ER              ercd;
 595
 596         switch (++task4_count) {
 597         case 1:
 598                 check_point(37);
 599                 ercd = loc_mtx(MTX2);
 600                 check_ercd(ercd, E_OK);
 601
 602                 check_point(43);
 603                 ercd = ext_tsk();
 604
 605                 check_point(0);
 606
 607         case 2:
 608                 check_point(49);
 609                 ercd = loc_mtx(MTX2);
 610                 check_ercd(ercd, E_OK);
 611
 612                 check_point(53);
 613                 ercd = ext_tsk();
 614
 615                 check_point(0);
 616         }
 617         check_point(0);
 618 }