path: root/spec/score/val/fatal.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: true
links: []
test-actions:
- action-brief: |
    Construct a task with a task body which returns.  Check that the right
    fatal error occurs.
  action-code: |
    rtems_id     id;
    unsigned int counter;

    SetFatalHandler( FatalTaskExit, ctx );
    SetSelfPriority( PRIO_NORMAL );
    counter = ResetFatalInfo( ctx );
    id = CreateTask( "EXIT", PRIO_HIGH );
    StartTask( id, ExitTask, NULL );
    T_eq_uint( GetFatalCounter( ctx ), counter + 1 );
    T_eq_int( ctx->source, INTERNAL_ERROR_CORE );
    T_eq_ulong( ctx->code, INTERNAL_ERROR_THREAD_EXITTED );
    RestoreRunnerPriority();
    SetFatalHandler( NULL, NULL );
  checks: []
  links:
  - role: validation
    uid: ../thread/req/fatal-thread-exitted
- action-brief: |
    Construct a task which performs a thread dispatch with maskable interrupts
    disabled.  Check that the right fatal error occurs or no fatal error
    occurs.
  action-code: |
    rtems_id     id;
    unsigned int counter;

    SetFatalHandler( FatalBadThreadDispatchEnvironment, ctx );
    SetSelfPriority( PRIO_NORMAL );
    counter = ResetFatalInfo( ctx );
    id = CreateTask( "BENV", PRIO_HIGH );
    StartTask( id, ISRDisabledThreadDispatchTask, NULL );

    #if CPU_ENABLE_ROBUST_THREAD_DISPATCH == FALSE
    if ( rtems_configuration_get_maximum_processors() > 1 ) {
    #endif
      T_eq_uint( GetFatalCounter( ctx ), counter + 1 );
      T_eq_int( ctx->source, INTERNAL_ERROR_CORE );
      T_eq_ulong( ctx->code, INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT );
    #if CPU_ENABLE_ROBUST_THREAD_DISPATCH == FALSE
    } else {
      T_eq_uint( GetFatalCounter( ctx ), counter );
    }
    #endif

    RestoreRunnerPriority();
    SetFatalHandler( NULL, NULL );
  checks: []
  links:
  - role: validation
    uid: ../thread/req/fatal-bad-thread-dispatch-environment-ipi
  - role: validation
    uid: ../thread/req/fatal-bad-thread-dispatch-environment-robust
  - role: validation
    uid: ../thread/req/thread-dispatch-isr-disabled
- action-brief: |
    Construct a task which performs a direct thread dispatch with a thread
    dispatch level not equal to one.  Check that the right fatal error occurs.
  action-code: |
    rtems_id     id;
    unsigned int counter;

    SetFatalHandler( FatalBadThreadDispatchDisableLevel, ctx );
    SetSelfPriority( PRIO_NORMAL );
    counter = ResetFatalInfo( ctx );
    id = CreateTask( "BLVL", PRIO_HIGH );
    StartTask( id, BadLevelThreadDispatchTask, NULL );
    T_eq_uint( GetFatalCounter( ctx ), counter + 1 );
    T_eq_int( ctx->source, INTERNAL_ERROR_CORE );
    T_eq_ulong( ctx->code, INTERNAL_ERROR_BAD_THREAD_DISPATCH_DISABLE_LEVEL );
    RestoreRunnerPriority();
    SetFatalHandler( NULL, NULL );
  checks: []
  links:
  - role: validation
    uid: ../thread/req/fatal-bad-thread-dispatch-disable-level
- action-brief: |
    Create a mutex and construct a task which produces a deadlock which
    involves the allocator mutex.
  action-code: |
    rtems_extensions_table extensions;
    rtems_status_code      sc;
    rtems_id               extension_id;
    rtems_id               task_id;
    unsigned int           counter;

    memset( &extensions, 0, sizeof( extensions ) );
    extensions.thread_create = ThreadCreateDeadlock;

    sc = rtems_extension_create(
      rtems_build_name( 'T', 'E', 'X', 'T' ),
      &extensions,
      &extension_id
    );
    T_rsc_success( sc );

    deadlock_mutex = CreateMutex();

    SetFatalHandler( FatalJumpBack, ctx );
    SetSelfPriority( PRIO_NORMAL );
    counter = ResetFatalInfo( ctx );

    ObtainMutex( deadlock_mutex );

    task_id = CreateTask( "WORK", PRIO_HIGH );
    StartTask( task_id, ThreadQueueDeadlockTask, NULL );

    if ( setjmp( before_fatal ) == 0 ) {
      (void) CreateTask( "DLCK", PRIO_NORMAL );
    }

    ReleaseMutex( deadlock_mutex );

    T_eq_uint( GetFatalCounter( ctx ), counter + 1 );
    T_eq_int( ctx->source, INTERNAL_ERROR_CORE );
    T_eq_ulong( ctx->code, INTERNAL_ERROR_THREAD_QUEUE_DEADLOCK );

    RestoreRunnerPriority();

    sc = rtems_extension_delete( extension_id );
    T_rsc_success( sc );

    DeleteMutex( deadlock_mutex );
  checks: []
  links:
  - role: validation
    uid: ../object/req/fatal-allocator-mutex-deadlock
- action-brief: |
    Check that ${/rtems/fatal/if/fatal:/name} terminates the system.  Since
    SetFatalHandler() requires an initial extension this validates
    ${/acfg/if/initial-extensions:/name}.
  action-code: |
    unsigned int counter;

    SetFatalHandler( FatalJumpBack, ctx );
    counter = ResetFatalInfo( ctx );

    if ( setjmp( before_fatal ) == 0 ) {
      rtems_fatal( 123, 4567890 );
    }

    T_eq_uint( GetFatalCounter( ctx ), counter + 1 );
    T_eq_int( ctx->source, 123 );
    T_eq_ulong( ctx->code, 4567890 );
  checks: []
  links:
  - role: validation
    uid: /rtems/fatal/req/fatal
  - role: validation
    uid: /acfg/req/initial-extensions
test-brief: |
  Tests some fatal errors.
test-context:
- brief: |
    This member is a fatal extension invocation counter.
  description: null
  member: |
    Atomic_Uint counter
- brief: |
    This member contains the last fatal source.
  description: null
  member: |
    rtems_fatal_source source
- brief: |
    This member contains the last fatal code.
  description: null
  member: |
    rtems_fatal_code code
test-context-support: null
test-description: null
test-header: null
test-includes:
- rtems.h
- rtems/score/atomic.h
- rtems/score/isrlevel.h
- rtems/score/threaddispatch.h
- setjmp.h
- string.h
test-local-includes:
- tx-support.h
test-setup: null
test-stop: null
test-support: |
  typedef ${.:/test-context-type} Context;

  static unsigned int GetFatalCounter( const Context *ctx )
  {
    return _Atomic_Load_uint( &ctx->counter, ATOMIC_ORDER_RELAXED );
  }

  static unsigned int ResetFatalInfo( Context *ctx )
  {
    ctx->source = RTEMS_FATAL_SOURCE_APPLICATION;
    ctx->code = INTERNAL_ERROR_NO_MPCI;

    return GetFatalCounter( ctx );
  }

  static void Fatal(
    rtems_fatal_source source,
    rtems_fatal_code   code,
    Context           *ctx
  )
  {
    ctx->source = source;
    ctx->code = code;
    _Atomic_Fetch_add_uint( &ctx->counter, 1, ATOMIC_ORDER_RELAXED );
  }

  static void FatalTaskExit(
    rtems_fatal_source source,
    rtems_fatal_code   code,
    void              *arg
  )
  {
    Fatal( source, code, arg );
    rtems_task_exit();
  }

  static void ExitTask( rtems_task_argument arg )
  {
    (void) arg;
  }

  static void FatalBadThreadDispatchEnvironment(
    rtems_fatal_source source,
    rtems_fatal_code   code,
    void              *arg
  )
  {
    Fatal( source, code, arg );
    _ISR_Set_level( 0 );
    _Thread_Dispatch_direct_no_return( _Per_CPU_Get() );
  }

  static void ISRDisabledThreadDispatchTask( rtems_task_argument arg )
  {
    rtems_interrupt_level level;

    (void) arg;
    rtems_interrupt_local_disable( level );
    (void) level;
    rtems_task_exit();
  }

  static void FatalBadThreadDispatchDisableLevel(
    rtems_fatal_source source,
    rtems_fatal_code   code,
    void              *arg
  )
  {
    Per_CPU_Control *cpu_self;

    Fatal( source, code, arg );
    cpu_self = _Per_CPU_Get();
    _Thread_Dispatch_unnest( cpu_self );
    _Thread_Dispatch_direct_no_return( cpu_self );
  }

  static void BadLevelThreadDispatchTask( rtems_task_argument arg )
  {
    (void) arg;
    _Thread_Dispatch_disable();
    rtems_task_exit();
  }

  static jmp_buf before_fatal;

  static rtems_id deadlock_mutex;

  static bool ThreadCreateDeadlock( rtems_tcb *executing, rtems_tcb *created )
  {
    (void) executing;
    (void) created;

    ObtainMutex( deadlock_mutex );
    ReleaseMutex( deadlock_mutex );

    return true;
  }

  static void FatalJumpBack(
    rtems_fatal_source source,
    rtems_fatal_code   code,
    void              *arg
  )
  {
    SetFatalHandler( NULL, NULL );
    Fatal( source, code, arg );
    longjmp( before_fatal, 1 );
  }

  static void ThreadQueueDeadlockTask( rtems_task_argument arg )
  {
    rtems_id id;

    (void) arg;
    id = CreateTask( "DORM", PRIO_NORMAL );
    DeleteTask( id );

    rtems_task_exit();
  }
test-target: testsuites/validation/tc-score-fatal.c
test-teardown: null
type: test-case