LXR 6.1/​testsuites/​validation/​tc-sem-smp.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:24:52

 /* SPDX-License-Identifier: BSD-2-Clause */
 
 /**
  * @file
  *
  * @ingroup RtemsSemValSmp
  */
 
 /*
  * Copyright (C) 2021 embedded brains GmbH & Co. KG
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
 /*
  * This file is part of the RTEMS quality process and was automatically
  * generated.  If you find something that needs to be fixed or
  * worded better please post a report or patch to an RTEMS mailing list
  * or raise a bug report:
  *
  * https://www.rtems.org/bugs.html
  *
  * For information on updating and regenerating please refer to the How-To
  * section in the Software Requirements Engineering chapter of the
  * RTEMS Software Engineering manual.  The manual is provided as a part of
  * a release.  For development sources please refer to the online
  * documentation at:
  *
  * https://docs.rtems.org
  */
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <rtems.h>
 #include <rtems/score/threaddispatch.h>
 
 #include "ts-config.h"
 #include "tx-support.h"
 
 #include <rtems/test.h>
 
 /**
  * @defgroup RtemsSemValSmp spec:/rtems/sem/val/smp
  *
  * @ingroup TestsuitesValidationSmpOnly0
  *
  * @brief Tests SMP-specific semaphore behaviour.
  *
  * This test case performs the following actions:
  *
  * - Create a worker thread and a MrsP mutex.  Use the mutex and the worker to
  *   perform a bad sticky thread queue enqueue.
  *
  * - Create two worker threads, a MrsP mutex, and a priority inheritance mutex.
  *   Use the mutexes and the workers to raise the current priority to a higher
  *   priority than the ceiling priority of the mutex while one of the workers
  *   waits on the mutex.
  *
  *   - Let the first worker try to obtain the MrsP mutex.  Check that it
  *     acquired the ceiling priority.
  *
  *   - Let the second worker try to obtain the priority inheritance mutex.
  *     Check that the first worker inherited the priority from the second
  *     worker.
  *
  *   - Set the real priority of the first worker.  Check that it defines the
  *     current priority.
  *
  *   - 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.
  *
  *   - Obtain the MrsP mutex for the runner thread to start the second scenario
  *     we would like to test.
  *
  *   - Let the first worker try to obtain the MrsP mutex.  Check that it
  *     acquired the ceiling priority.
  *
  *   - Let the second worker try to obtain the priority inheritance mutex.
  *     Check that the first worker inherited the priority from the second
  *     worker.
  *
  *   - Lower the priority of the second worker.  Check that the inherited
  *     priority of the first worker reflects this priority change.
  *
  *   - Change the real priority of the first worker so that it defines its
  *     current priority.
  *
  *   - 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.
  *
  *   - Clean up all used resources.
  *
  * @{
  */
 
 /**
  * @brief Test context for spec:/rtems/sem/val/smp test case.
  */
 typedef struct {
   /**
    * @brief This member contains the mutex identifier.
    */
   rtems_id mutex_id;
 
   /**
    * @brief This member contains the second mutex identifier.
    */
   rtems_id mutex_2_id;
 
   /**
    * @brief If this member is true, then the worker is done.
    */
   volatile bool done;
 
   /**
    * @brief If this member is true, then the second worker is done.
    */
   volatile bool done_2;
 } RtemsSemValSmp_Context;
 
 static RtemsSemValSmp_Context
   RtemsSemValSmp_Instance;
 
 typedef RtemsSemValSmp_Context 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 );
 
   _ISR_Set_level( 0 );
   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();
 }
 
 static void RtemsSemValSmp_Setup( RtemsSemValSmp_Context *ctx )
 {
   SetSelfPriority( PRIO_NORMAL );
 }
 
 static void RtemsSemValSmp_Setup_Wrap( void *arg )
 {
   RtemsSemValSmp_Context *ctx;
 
   ctx = arg;
   RtemsSemValSmp_Setup( ctx );
 }
 
 static void RtemsSemValSmp_Teardown( RtemsSemValSmp_Context *ctx )
 {
   RestoreRunnerPriority();
 }
 
 static void RtemsSemValSmp_Teardown_Wrap( void *arg )
 {
   RtemsSemValSmp_Context *ctx;
 
   ctx = arg;
   RtemsSemValSmp_Teardown( ctx );
 }
 
 static T_fixture RtemsSemValSmp_Fixture = {
   .setup = RtemsSemValSmp_Setup_Wrap,
   .stop = NULL,
   .teardown = RtemsSemValSmp_Teardown_Wrap,
   .scope = NULL,
   .initial_context = &RtemsSemValSmp_Instance
 };
 
 /**
  * @brief Create a worker thread and a MrsP mutex.  Use the mutex and the
  *   worker to perform a bad sticky thread queue enqueue.
  */
 static void RtemsSemValSmp_Action_0( RtemsSemValSmp_Context *ctx )
 {
   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 );
 }
 
 /**
  * @brief Create two worker threads, a MrsP mutex, and a priority inheritance
  *   mutex. Use the mutexes and the workers to raise the current priority to a
  *   higher priority than the ceiling priority of the mutex while one of the
  *   workers waits on the mutex.
  */
 static void RtemsSemValSmp_Action_1( RtemsSemValSmp_Context *ctx )
 {
   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 );
 
   /*
    * Let the first worker try to obtain the MrsP mutex.  Check that it acquired
    * the ceiling priority.
    */
   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 );
 
   /*
    * Let the second worker try to obtain the priority inheritance mutex. Check
    * that the first worker inherited the priority from the second worker.
    */
   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 );
 
   /*
    * Set the real priority of the first worker.  Check that it defines the
    * current priority.
    */
   SetPriority( worker_id, PRIO_ULTRA_HIGH );
 
   prio = GetPriorityByScheduler( worker_id, scheduler_b_id );
   T_eq_u32( prio, PRIO_ULTRA_HIGH );
 
   /*
    * 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.
    */
   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 );
 
   /*
    * Obtain the MrsP mutex for the runner thread to start the second scenario
    * we would like to test.
    */
   ObtainMutex( ctx->mutex_id );
 
   /*
    * Let the first worker try to obtain the MrsP mutex.  Check that it acquired
    * the ceiling priority.
    */
   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 );
 
   /*
    * Let the second worker try to obtain the priority inheritance mutex. Check
    * that the first worker inherited the priority from the second worker.
    */
   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 );
 
   /*
    * Lower the priority of the second worker.  Check that the inherited
    * priority of the first worker reflects this priority change.
    */
   SetPriority( worker_2_id, PRIO_LOW );
 
   prio = GetPriorityByScheduler( worker_id, scheduler_b_id );
   T_eq_u32( prio, PRIO_HIGH );
 
   /*
    * Change the real priority of the first worker so that it defines its
    * current priority.
    */
   SetPriority( worker_id, PRIO_ULTRA_HIGH );
 
   prio = GetPriorityByScheduler( worker_id, scheduler_b_id );
   T_eq_u32( prio, PRIO_ULTRA_HIGH );
 
   /*
    * 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.
    */
   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 );
 
   /*
    * Clean up all used resources.
    */
   DeleteTask( worker_id );
   DeleteTask( worker_2_id );
   DeleteMutex( ctx->mutex_id );
   DeleteMutex( ctx->mutex_2_id );
 }
 
 /**
  * @fn void T_case_body_RtemsSemValSmp( void )
  */
 T_TEST_CASE_FIXTURE( RtemsSemValSmp, &RtemsSemValSmp_Fixture )
 {
   RtemsSemValSmp_Context *ctx;
 
   ctx = T_fixture_context();
 
   RtemsSemValSmp_Action_0( ctx );
   RtemsSemValSmp_Action_1( ctx );
 }
 
 /** @} */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team