From cdc1eb7dcc6612d8e0eb23fc4b1582d3219742e9 Mon Sep 17 00:00:00 2001 From: Sebastian Huber Date: Tue, 12 Jul 2022 17:17:00 +0200 Subject: validation: SMP-specific spurious interrupt test Update #3716. --- testsuites/validation/tc-bsp-interrupt-spurious.c | 148 ++++++++++++++++++---- 1 file changed, 125 insertions(+), 23 deletions(-) (limited to 'testsuites/validation/tc-bsp-interrupt-spurious.c') diff --git a/testsuites/validation/tc-bsp-interrupt-spurious.c b/testsuites/validation/tc-bsp-interrupt-spurious.c index 0cb14f8f1a..f5e992a51d 100644 --- a/testsuites/validation/tc-bsp-interrupt-spurious.c +++ b/testsuites/validation/tc-bsp-interrupt-spurious.c @@ -74,6 +74,12 @@ typedef enum { BspReqInterruptSpurious_Pre_First_NA } BspReqInterruptSpurious_Pre_First; +typedef enum { + BspReqInterruptSpurious_Pre_FirstAgain_Null, + BspReqInterruptSpurious_Pre_FirstAgain_Entry, + BspReqInterruptSpurious_Pre_FirstAgain_NA +} BspReqInterruptSpurious_Pre_FirstAgain; + typedef enum { BspReqInterruptSpurious_Post_Result_FatalError, BspReqInterruptSpurious_Post_Result_Dispatch, @@ -93,6 +99,7 @@ typedef enum { typedef struct { uint8_t Skip : 1; uint8_t Pre_First_NA : 1; + uint8_t Pre_FirstAgain_NA : 1; uint8_t Post_Result : 2; uint8_t Post_FatalSource : 1; uint8_t Post_FatalCode : 1; @@ -153,11 +160,23 @@ typedef struct { */ rtems_interrupt_entry **first; + /** + * @brief This member references an interrupt entry for the first entry of + * the interrupt vector or is NULL. + */ + rtems_interrupt_entry *first_again; + struct { + /** + * @brief This member defines the pre-condition indices for the next + * action. + */ + size_t pci[ 2 ]; + /** * @brief This member defines the pre-condition states for the next action. */ - size_t pcs[ 1 ]; + size_t pcs[ 2 ]; /** * @brief If this member is true, then the test action loop is executed. @@ -191,8 +210,15 @@ static const char * const BspReqInterruptSpurious_PreDesc_First[] = { "NA" }; +static const char * const BspReqInterruptSpurious_PreDesc_FirstAgain[] = { + "Null", + "Entry", + "NA" +}; + static const char * const * const BspReqInterruptSpurious_PreDesc[] = { BspReqInterruptSpurious_PreDesc_First, + BspReqInterruptSpurious_PreDesc_FirstAgain, NULL }; @@ -271,8 +297,9 @@ static void BspReqInterruptSpurious_Pre_First_Prepare( switch ( state ) { case BspReqInterruptSpurious_Pre_First_Null: { /* - * While the pointer to the first interrupt entry of the interrupt vector - * specified by the ``vector`` parameter is equal to NULL. + * While the first loaded value of the pointer to the first interrupt + * entry of the interrupt vector specified by the ``vector`` parameter is + * equal to NULL. */ *ctx->first = NULL; break; @@ -280,9 +307,9 @@ static void BspReqInterruptSpurious_Pre_First_Prepare( case BspReqInterruptSpurious_Pre_First_Entry: { /* - * While the pointer to the first interrupt entry of the interrupt vector - * specified by the ``vector`` parameter references an object of type - * rtems_interrupt_entry. + * While the first loaded value of the pointer to the first interrupt + * entry of the interrupt vector specified by the ``vector`` parameter + * references an object of type rtems_interrupt_entry. */ *ctx->first = &ctx->entry; break; @@ -293,6 +320,37 @@ static void BspReqInterruptSpurious_Pre_First_Prepare( } } +static void BspReqInterruptSpurious_Pre_FirstAgain_Prepare( + BspReqInterruptSpurious_Context *ctx, + BspReqInterruptSpurious_Pre_FirstAgain state +) +{ + switch ( state ) { + case BspReqInterruptSpurious_Pre_FirstAgain_Null: { + /* + * While the second loaded value of the pointer to the first interrupt + * entry of the interrupt vector specified by the ``vector`` parameter is + * equal to NULL. + */ + ctx->first_again = NULL; + break; + } + + case BspReqInterruptSpurious_Pre_FirstAgain_Entry: { + /* + * While the second loaded value of the pointer to the first interrupt + * entry of the interrupt vector specified by the ``vector`` parameter + * references an object of type rtems_interrupt_entry. + */ + ctx->first_again = &ctx->entry; + break; + } + + case BspReqInterruptSpurious_Pre_FirstAgain_NA: + break; + } +} + static void BspReqInterruptSpurious_Post_Result_Check( BspReqInterruptSpurious_Context *ctx, BspReqInterruptSpurious_Post_Result state @@ -416,39 +474,62 @@ static void BspReqInterruptSpurious_Action( BspReqInterruptSpurious_Context *ctx ) { - rtems_status_code sc; - ctx->interrupt_occurred = false; ctx->entry_counter = 0; ctx->fatal_counter = 0; ctx->fatal_source = RTEMS_FATAL_SOURCE_LAST; ctx->fatal_code = UINT32_MAX; - (void) rtems_interrupt_vector_enable( ctx->test_vector ); + #if defined(RTEMS_SMP) + if ( *ctx->first == NULL && ctx->first_again != NULL ) { + *ctx->first = ctx->first_again; + bsp_interrupt_spurious( ctx->test_vector ); + } else + #endif + { + rtems_status_code sc; - sc = rtems_interrupt_raise( ctx->test_vector ); - T_rsc_success( sc ); + (void) rtems_interrupt_vector_enable( ctx->test_vector ); - while ( !ctx->interrupt_occurred ) { - /* Wait */ - } + sc = rtems_interrupt_raise( ctx->test_vector ); + T_rsc_success( sc ); - Disable( ctx ); + while ( !ctx->interrupt_occurred ) { + /* Wait */ + } + + Disable( ctx ); + } } static const BspReqInterruptSpurious_Entry BspReqInterruptSpurious_Entries[] = { - { 0, 0, BspReqInterruptSpurious_Post_Result_FatalError, + { 0, 0, 1, BspReqInterruptSpurious_Post_Result_Dispatch, + BspReqInterruptSpurious_Post_FatalSource_NA, + BspReqInterruptSpurious_Post_FatalCode_NA }, +#if defined(RTEMS_SMP) + { 0, 0, 0, BspReqInterruptSpurious_Post_Result_FatalError, BspReqInterruptSpurious_Post_FatalSource_SpuriousInterrupt, BspReqInterruptSpurious_Post_FatalCode_Vector }, - { 0, 0, BspReqInterruptSpurious_Post_Result_Dispatch, +#else + { 0, 0, 1, BspReqInterruptSpurious_Post_Result_FatalError, + BspReqInterruptSpurious_Post_FatalSource_SpuriousInterrupt, + BspReqInterruptSpurious_Post_FatalCode_Vector }, +#endif +#if defined(RTEMS_SMP) + { 0, 0, 0, BspReqInterruptSpurious_Post_Result_Dispatch, BspReqInterruptSpurious_Post_FatalSource_NA, BspReqInterruptSpurious_Post_FatalCode_NA } +#else + { 0, 0, 1, BspReqInterruptSpurious_Post_Result_FatalError, + BspReqInterruptSpurious_Post_FatalSource_SpuriousInterrupt, + BspReqInterruptSpurious_Post_FatalCode_Vector } +#endif }; static const uint8_t BspReqInterruptSpurious_Map[] = { - 0, 1 + 1, 2, 0, 0 }; static size_t BspReqInterruptSpurious_Scope( void *arg, char *buf, size_t n ) @@ -490,11 +571,25 @@ static inline BspReqInterruptSpurious_Entry BspReqInterruptSpurious_PopEntry( ]; } +static void BspReqInterruptSpurious_SetPreConditionStates( + BspReqInterruptSpurious_Context *ctx +) +{ + ctx->Map.pcs[ 0 ] = ctx->Map.pci[ 0 ]; + + if ( ctx->Map.entry.Pre_FirstAgain_NA ) { + ctx->Map.pcs[ 1 ] = BspReqInterruptSpurious_Pre_FirstAgain_NA; + } else { + ctx->Map.pcs[ 1 ] = ctx->Map.pci[ 1 ]; + } +} + static void BspReqInterruptSpurious_TestVariant( BspReqInterruptSpurious_Context *ctx ) { BspReqInterruptSpurious_Pre_First_Prepare( ctx, ctx->Map.pcs[ 0 ] ); + BspReqInterruptSpurious_Pre_FirstAgain_Prepare( ctx, ctx->Map.pcs[ 1 ] ); BspReqInterruptSpurious_Action( ctx ); BspReqInterruptSpurious_Post_Result_Check( ctx, ctx->Map.entry.Post_Result ); BspReqInterruptSpurious_Post_FatalSource_Check( @@ -522,12 +617,19 @@ T_TEST_CASE_FIXTURE( ctx->Map.index = 0; for ( - ctx->Map.pcs[ 0 ] = BspReqInterruptSpurious_Pre_First_Null; - ctx->Map.pcs[ 0 ] < BspReqInterruptSpurious_Pre_First_NA; - ++ctx->Map.pcs[ 0 ] + ctx->Map.pci[ 0 ] = BspReqInterruptSpurious_Pre_First_Null; + ctx->Map.pci[ 0 ] < BspReqInterruptSpurious_Pre_First_NA; + ++ctx->Map.pci[ 0 ] ) { - ctx->Map.entry = BspReqInterruptSpurious_PopEntry( ctx ); - BspReqInterruptSpurious_TestVariant( ctx ); + for ( + ctx->Map.pci[ 1 ] = BspReqInterruptSpurious_Pre_FirstAgain_Null; + ctx->Map.pci[ 1 ] < BspReqInterruptSpurious_Pre_FirstAgain_NA; + ++ctx->Map.pci[ 1 ] + ) { + ctx->Map.entry = BspReqInterruptSpurious_PopEntry( ctx ); + BspReqInterruptSpurious_SetPreConditionStates( ctx ); + BspReqInterruptSpurious_TestVariant( ctx ); + } } } -- cgit v1.2.3