path: root/spec/rtems/sem/val/smp.yml

SPDX-License-Identifier: CC-BY-SA-4.0 OR BSD-2-Clause
copyrights:
- Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de)
enabled-by: RTEMS_SMP
links: []
test-actions:
- action-brief: |
    Create a worker thread and a MrsP mutex.  Use the mutex and the worker to
    perform a bad sticky thread queue enqueue.
  action-code: |
    rtems_status_code sc;
    rtems_id          worker_id;
    rtems_id          scheduler_b_id;

    ctx->done = false;

    sc = rtems_scheduler_ident( TEST_SCHEDULER_B_NAME, &scheduler_b_id );
    T_rsc_success( sc );

    sc = rtems_semaphore_create(
      rtems_build_name( 'M', 'U', 'T', 'X' ),
      1,
      RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY |
        RTEMS_MULTIPROCESSOR_RESOURCE_SHARING,
      PRIO_HIGH,
      &ctx->mutex_id
    );
    T_rsc_success( sc );

    worker_id = CreateTask( "WORK", PRIO_NORMAL );
    SetScheduler( worker_id, scheduler_b_id, PRIO_NORMAL );

    ObtainMutex( ctx->mutex_id );
    SetFatalHandler( BadEnqueueFatal, ctx );
    StartTask( worker_id, BadEnqueueTask, ctx );

    while ( !ctx->done ) {
      /* Wait */
    }

    DeleteTask( worker_id );
    ReleaseMutex( ctx->mutex_id );
    DeleteMutex( ctx->mutex_id );
  checks: []
  links:
  - role: validation
    uid: /score/tq/req/fatal-enqueue-sticky-from-bad-state
- action-brief: |
    Create two worker threads, a MrsP mutex, and a priority inheritance mutex.
    Use the mutexes and the workers to raise the
    ${/glossary/priority-current:/term} to a higher priority than the ceiling
    priority of the mutex while one of the workers waits on the mutex.
  action-code: |
    rtems_status_code   sc;
    rtems_id            worker_id;
    rtems_id            worker_2_id;
    rtems_id            scheduler_b_id;
    rtems_task_priority prio;

    sc = rtems_scheduler_ident( TEST_SCHEDULER_B_NAME, &scheduler_b_id );
    T_rsc_success( sc );

    sc = rtems_semaphore_create(
      rtems_build_name( 'M', 'U', 'T', 'X' ),
      1,
      RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY |
        RTEMS_MULTIPROCESSOR_RESOURCE_SHARING,
      PRIO_HIGH,
      &ctx->mutex_id
    );
    T_rsc_success( sc );

    sc = rtems_semaphore_set_priority(
      ctx->mutex_id,
      scheduler_b_id,
      PRIO_HIGH,
      &prio
    );
    T_rsc_success( sc );

    ctx->mutex_2_id = CreateMutex();

    worker_id = CreateTask( "WORK", PRIO_NORMAL );
    SetScheduler( worker_id, scheduler_b_id, PRIO_NORMAL );

    worker_2_id = CreateTask( "WRK2", PRIO_NORMAL );
    SetScheduler( worker_2_id, scheduler_b_id, PRIO_VERY_HIGH );
  checks:
  - brief: |
      Let the first worker try to obtain the MrsP mutex.  Check that it
      acquired the ceiling priority.
    code: |
      ObtainMutex( ctx->mutex_id );
      ctx->done = false;
      StartTask( worker_id, ObtainReleaseMrsPTask, ctx );

      while ( !ctx->done ) {
        /* Wait */
      }

      ctx->done = false;
      WaitForIntendToBlock( worker_id );
      prio = GetPriorityByScheduler( worker_id, scheduler_b_id );
      T_eq_u32( prio, PRIO_HIGH );
    links: []
  - brief: |
      Let the second worker try to obtain the priority inheritance mutex.
      Check that the first worker inherited the priority from the second
      worker.
    code: |
      ctx->done_2 = false;
      StartTask( worker_2_id, ObtainRelease2Task, ctx );

      while ( !ctx->done_2 ) {
        /* Wait */
      }

      ctx->done_2 = false;
      WaitForExecutionStop( worker_2_id );
      prio = GetPriorityByScheduler( worker_id, scheduler_b_id );
      T_eq_u32( prio, PRIO_VERY_HIGH );
    links: []
  - brief: |
      Set the ${/glossary/priority-real:/term} of the first worker.  Check that
      it defines the ${/glossary/priority-current:/term}.
    code: |
      SetPriority( worker_id, PRIO_ULTRA_HIGH );

      prio = GetPriorityByScheduler( worker_id, scheduler_b_id );
      T_eq_u32( prio, PRIO_ULTRA_HIGH );
    links: []
  - brief: |
      Release the MrsP mutex so that the first worker can to obtain it.  It
      will replace a temporary priority node which is the maximum priority
      node.  This is the first scenario we want to test.
    code: |
      ReleaseMutex( ctx->mutex_id );

      while ( !ctx->done || !ctx->done_2 ) {
        /* Wait */
      }

      prio = GetPriorityByScheduler( worker_id, scheduler_b_id );
      T_eq_u32( prio, PRIO_ULTRA_HIGH );
    links: []
  - brief: |
      Obtain the MrsP mutex for the runner thread to start the second scenario
      we would like to test.
    code: |
      ObtainMutex( ctx->mutex_id );
    links: []
  - brief: |
      Let the first worker try to obtain the MrsP mutex.  Check that it
      acquired the ceiling priority.
    code: |
      ctx->done = false;
      sc = rtems_task_restart( worker_id, (rtems_task_argument) ctx );
      T_rsc_success( sc );

      while ( !ctx->done ) {
        /* Wait */
      }

      ctx->done = false;
      WaitForIntendToBlock( worker_id );
      prio = GetPriorityByScheduler( worker_id, scheduler_b_id );
      T_eq_u32( prio, PRIO_HIGH );
    links: []
  - brief: |
      Let the second worker try to obtain the priority inheritance mutex.
      Check that the first worker inherited the priority from the second
      worker.
    code: |
      ctx->done_2 = false;
      sc = rtems_task_restart( worker_2_id, (rtems_task_argument) ctx );
      T_rsc_success( sc );

      while ( !ctx->done_2 ) {
        /* Wait */
      }

      ctx->done_2 = false;
      WaitForExecutionStop( worker_2_id );
      prio = GetPriorityByScheduler( worker_id, scheduler_b_id );
      T_eq_u32( prio, PRIO_VERY_HIGH );
    links: []
  - brief: |
      Lower the priority of the second worker.  Check that the inherited
      priority of the first worker reflects this priority change.
    code: |
      SetPriority( worker_2_id, PRIO_LOW );

      prio = GetPriorityByScheduler( worker_id, scheduler_b_id );
      T_eq_u32( prio, PRIO_HIGH );
    links: []
  - brief: |
      Change the ${/glossary/priority-real:/term} of the first worker so that
      it defines its ${/glossary/priority-current:/term}.
    code: |
      SetPriority( worker_id, PRIO_ULTRA_HIGH );

      prio = GetPriorityByScheduler( worker_id, scheduler_b_id );
      T_eq_u32( prio, PRIO_ULTRA_HIGH );
    links: []
  - brief: |
      Release the MrsP mutex so that the first worker can to obtain it.  It
      will replace a temporary priority node which is between the minimum and
      maximum priority node.  This is the second scenario we want to test.
    code: |
      ReleaseMutex( ctx->mutex_id );

      while ( !ctx->done || !ctx->done_2 ) {
        /* Wait */
      }

      prio = GetPriorityByScheduler( worker_id, scheduler_b_id );
      T_eq_u32( prio, PRIO_ULTRA_HIGH );
    links:
    - role: validation
      uid: ../req/mrsp-prio-change-while-waiting
  - brief: |
      Clean up all used resources.
    code: |
      DeleteTask( worker_id );
      DeleteTask( worker_2_id );
      DeleteMutex( ctx->mutex_id );
      DeleteMutex( ctx->mutex_2_id );
    links: []
  links: []
test-brief: |
  Tests SMP-specific semaphore behaviour.
test-context:
- brief: |
    This member contains the mutex identifier.
  description: null
  member: |
    rtems_id mutex_id;
- brief: |
    This member contains the second mutex identifier.
  description: null
  member: |
    rtems_id mutex_2_id;
- brief: |
    If this member is true, then the worker is done.
  description: null
  member: |
    volatile bool done
- brief: |
    If this member is true, then the second worker is done.
  description: null
  member: |
    volatile bool done_2
test-context-support: null
test-description: null
test-header: null
test-includes:
- rtems.h
- rtems/score/threaddispatch.h
test-local-includes:
- ts-config.h
- tx-support.h
test-setup:
  brief: null
  code: |
    SetSelfPriority( PRIO_NORMAL );
  description: null
test-stop: null
test-support: |
  typedef ${.:/test-context-type} Context;

  static void BadEnqueueFatal(
    rtems_fatal_source source,
    rtems_fatal_code   code,
    void              *arg
  )
  {
    Per_CPU_Control *cpu_self;
    Context         *ctx;

    T_eq_int( source, INTERNAL_ERROR_CORE );
    T_eq_ulong(
      code,
      INTERNAL_ERROR_THREAD_QUEUE_ENQUEUE_STICKY_FROM_BAD_STATE
    );

    SetFatalHandler( NULL, NULL );

    cpu_self = _Per_CPU_Get();
    _Thread_Dispatch_unnest( cpu_self );
    _Thread_Dispatch_unnest( cpu_self );

    ctx = arg;
    ctx->done = true;
    SuspendSelf();
  }

  static void BadEnqueueTask( rtems_task_argument arg )
  {
    Context *ctx;

    ctx = (Context *) arg;
    (void) _Thread_Dispatch_disable();
    ObtainMutex( ctx->mutex_id );
  }

  static void ObtainReleaseMrsPTask( rtems_task_argument arg )
  {
    Context *ctx;

    ctx = (Context *) arg;
    ObtainMutex( ctx->mutex_2_id );
    ctx->done = true;
    ObtainMutex( ctx->mutex_id );
    ReleaseMutex( ctx->mutex_id );
    ReleaseMutex( ctx->mutex_2_id );
    ctx->done = true;
    SuspendSelf();
  }

  static void ObtainRelease2Task( rtems_task_argument arg )
  {
    Context *ctx;

    ctx = (Context *) arg;
    ctx->done_2 = true;
    ObtainMutex( ctx->mutex_2_id );
    ReleaseMutex( ctx->mutex_2_id );
    ctx->done_2 = true;
    SuspendSelf();
  }
test-target: testsuites/validation/tc-sem-smp.c
test-teardown:
  brief: null
  code: |
    RestoreRunnerPriority();
  description: null
type: test-case