cpukit: Add and use Watchdog_Discipline.

Clock disciplines may be WATCHDOG_RELATIVE, WATCHDOG_ABSOLUTE,
or WATCHDOG_NO_TIMEOUT. A discipline of WATCHDOG_RELATIVE with
a timeout of WATCHDOG_NO_TIMEOUT is equivalent to a discipline
of WATCHDOG_NO_TIMEOUT.

updates #2732

53 files changed, 218 insertions, 183 deletions

diff --git a/cpukit/libnetworking/rtems/rtems_glue.c b/cpukit/libnetworking/rtems/rtems_glue.c
index e9b371f700..6e54f2f831 100644
--- a/cpukit/libnetworking/rtems/rtems_glue.c
+++ b/cpukit/libnetworking/rtems/rtems_glue.c
@@ -377,11 +377,14 @@ rtems_bsdnet_semaphore_obtain (void)
 		rtems_panic ("rtems-net: network sema obtain: network not initialised\n");
 	_Thread_queue_Context_initialize(&queue_context);
 	_ISR_lock_ISR_disable(&queue_context.Lock_context);
+        _Thread_queue_Context_set_discipline(
+          &queue_context,
+	  WATCHDOG_NO_TIMEOUT
+	);
 	status = _CORE_recursive_mutex_Seize (
 		&the_networkSemaphore->Core_control.Mutex.Recursive,
 		_Thread_Executing,
 		true,			/* wait */
-		WATCHDOG_NO_TIMEOUT,	/* forever */
 		_CORE_recursive_mutex_Seize_nested,
 		&queue_context
 	);
diff --git a/cpukit/posix/include/rtems/posix/pthreadimpl.h b/cpukit/posix/include/rtems/posix/pthreadimpl.h
index 988246ed53..5f14ef79af 100644
--- a/cpukit/posix/include/rtems/posix/pthreadimpl.h
+++ b/cpukit/posix/include/rtems/posix/pthreadimpl.h
@@ -61,9 +61,10 @@ RTEMS_INLINE_ROUTINE void _POSIX_Threads_Sporadic_timer_insert(
   the_thread->cpu_time_budget =
     _Timespec_To_ticks( &api->Attributes.schedparam.sched_ss_init_budget );
 
-  _Watchdog_Per_CPU_insert_relative(
+  _Watchdog_Per_CPU_insert(
     &api->Sporadic.Timer,
     _Per_CPU_Get(),
+    WATCHDOG_RELATIVE,
     _Timespec_To_ticks( &api->Attributes.schedparam.sched_ss_repl_period )
   );
 }
diff --git a/cpukit/posix/src/condwaitsupp.c b/cpukit/posix/src/condwaitsupp.c
index ebcb3c4baf..b2ed367cb7 100644
--- a/cpukit/posix/src/condwaitsupp.c
+++ b/cpukit/posix/src/condwaitsupp.c
@@ -68,12 +68,13 @@ int _POSIX_Condition_variables_Wait_support(
 
   if ( !already_timedout ) {
     _Thread_queue_Context_set_expected_level( &queue_context, 2 );
+    _Thread_queue_Context_set_timeout( &queue_context, timeout );
+    _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_RELATIVE );
     _Thread_queue_Enqueue_critical(
       &the_cond->Wait_queue.Queue,
       POSIX_CONDITION_VARIABLES_TQ_OPERATIONS,
       executing,
       STATES_WAITING_FOR_CONDITION_VARIABLE,
-      timeout,
       &queue_context
     );
   } else {
diff --git a/cpukit/posix/src/mqueuerecvsupp.c b/cpukit/posix/src/mqueuerecvsupp.c
index cbb0dc08b8..1a376d1d0e 100644
--- a/cpukit/posix/src/mqueuerecvsupp.c
+++ b/cpukit/posix/src/mqueuerecvsupp.c
@@ -97,13 +97,14 @@ ssize_t _POSIX_Message_queue_Receive_support(
    *  Now perform the actual message receive
    */
   executing = _Thread_Executing;
+  _Thread_queue_Context_set_timeout( &queue_context, timeout );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_RELATIVE );
   status = _CORE_message_queue_Seize(
     &the_mq->Message_queue,
     executing,
     msg_ptr,
     &length_out,
     do_wait,
-    timeout,
     &queue_context
   );
 
diff --git a/cpukit/posix/src/mqueuesendsupp.c b/cpukit/posix/src/mqueuesendsupp.c
index 9785fb2086..91c7c2cbb7 100644
--- a/cpukit/posix/src/mqueuesendsupp.c
+++ b/cpukit/posix/src/mqueuesendsupp.c
@@ -92,6 +92,8 @@ int _POSIX_Message_queue_Send_support(
    *  Now perform the actual message receive
    */
   executing = _Thread_Executing;
+  _Thread_queue_Context_set_timeout( &queue_context, timeout );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_RELATIVE );
   status = _CORE_message_queue_Submit(
     &the_mq->Message_queue,
     executing,
@@ -99,7 +101,6 @@ int _POSIX_Message_queue_Send_support(
     msg_len,
     _POSIX_Message_queue_Priority_to_core( msg_prio ),
     do_wait,
-    timeout,
     &queue_context
   );
   return _POSIX_Zero_or_minus_one_plus_errno( status );
diff --git a/cpukit/posix/src/mutexlocksupp.c b/cpukit/posix/src/mutexlocksupp.c
index d3d07f68e8..c4079ef957 100644
--- a/cpukit/posix/src/mutexlocksupp.c
+++ b/cpukit/posix/src/mutexlocksupp.c
@@ -63,6 +63,8 @@ int _POSIX_Mutex_Lock_support(
   }
 
   executing = _Thread_Executing;
+  _Thread_queue_Context_set_timeout( &queue_context, timeout );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_RELATIVE );
 
   switch ( the_mutex->protocol ) {
     case POSIX_MUTEX_PRIORITY_CEILING:
@@ -70,7 +72,6 @@ int _POSIX_Mutex_Lock_support(
         &the_mutex->Mutex,
         executing,
         wait,
-        timeout,
         _POSIX_Mutex_Lock_nested,
         &queue_context
       );
@@ -81,7 +82,6 @@ int _POSIX_Mutex_Lock_support(
         POSIX_MUTEX_NO_PROTOCOL_TQ_OPERATIONS,
         executing,
         wait,
-        timeout,
         _POSIX_Mutex_Lock_nested,
         &queue_context
       );
@@ -92,7 +92,6 @@ int _POSIX_Mutex_Lock_support(
         &the_mutex->Mutex.Recursive,
         executing,
         wait,
-        timeout,
         _POSIX_Mutex_Lock_nested,
         &queue_context
       );
diff --git a/cpukit/posix/src/nanosleep.c b/cpukit/posix/src/nanosleep.c
index e0e1b2676e..8fc86d6503 100644
--- a/cpukit/posix/src/nanosleep.c
+++ b/cpukit/posix/src/nanosleep.c
@@ -93,6 +93,7 @@ int nanosleep(
     executing,
     STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL,
     ticks,
+    WATCHDOG_RELATIVE,
     1
   );
 
diff --git a/cpukit/posix/src/pbarrierwait.c b/cpukit/posix/src/pbarrierwait.c
index 0197e46702..6a72d9b800 100644
--- a/cpukit/posix/src/pbarrierwait.c
+++ b/cpukit/posix/src/pbarrierwait.c
@@ -41,11 +41,11 @@ int pthread_barrier_wait(
     return EINVAL;
   }
 
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_NO_TIMEOUT );
   status = _CORE_barrier_Seize(
     &the_barrier->Barrier,
     _Thread_Executing,
     true,
-    WATCHDOG_NO_TIMEOUT,
     &queue_context
   );
   return _POSIX_Get_error( status );
diff --git a/cpukit/posix/src/prwlockrdlock.c b/cpukit/posix/src/prwlockrdlock.c
index 295148e4bf..5bb9215dbe 100644
--- a/cpukit/posix/src/prwlockrdlock.c
+++ b/cpukit/posix/src/prwlockrdlock.c
@@ -35,11 +35,11 @@ int pthread_rwlock_rdlock(
     return EINVAL;
   }
 
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_NO_TIMEOUT );
   status = _CORE_RWLock_Seize_for_reading(
     &the_rwlock->RWLock,
     _Thread_Executing,
     true,                 /* we are willing to wait forever */
-    0,
     &queue_context
   );
   return _POSIX_Get_error( status );
diff --git a/cpukit/posix/src/prwlocktimedrdlock.c b/cpukit/posix/src/prwlocktimedrdlock.c
index 1c1059051b..c7f16002fd 100644
--- a/cpukit/posix/src/prwlocktimedrdlock.c
+++ b/cpukit/posix/src/prwlocktimedrdlock.c
@@ -56,11 +56,12 @@ int pthread_rwlock_timedrdlock(
     return EINVAL;
   }
 
+  _Thread_queue_Context_set_timeout( &queue_context, ticks );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_RELATIVE );
   status = _CORE_RWLock_Seize_for_reading(
     &the_rwlock->RWLock,
     _Thread_Executing,
     do_wait,
-    ticks,
     &queue_context
   );
 
diff --git a/cpukit/posix/src/prwlocktimedwrlock.c b/cpukit/posix/src/prwlocktimedwrlock.c
index 8080a8a920..ad6af40788 100644
--- a/cpukit/posix/src/prwlocktimedwrlock.c
+++ b/cpukit/posix/src/prwlocktimedwrlock.c
@@ -58,11 +58,12 @@ int pthread_rwlock_timedwrlock(
     return EINVAL;
   }
 
+  _Thread_queue_Context_set_timeout( &queue_context, ticks );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_RELATIVE );
   status = _CORE_RWLock_Seize_for_writing(
     &the_rwlock->RWLock,
     _Thread_Executing,
     do_wait,
-    ticks,
     &queue_context
   );
 
diff --git a/cpukit/posix/src/prwlocktryrdlock.c b/cpukit/posix/src/prwlocktryrdlock.c
index 5c6931ec0d..052f1b011e 100644
--- a/cpukit/posix/src/prwlocktryrdlock.c
+++ b/cpukit/posix/src/prwlocktryrdlock.c
@@ -39,7 +39,6 @@ int pthread_rwlock_tryrdlock(
     &the_rwlock->RWLock,
     _Thread_Executing,
     false,                  /* do not wait for the rwlock */
-    0,
     &queue_context
   );
   return _POSIX_Get_error( status );
diff --git a/cpukit/posix/src/prwlocktrywrlock.c b/cpukit/posix/src/prwlocktrywrlock.c
index 1181382fca..976e7a84ac 100644
--- a/cpukit/posix/src/prwlocktrywrlock.c
+++ b/cpukit/posix/src/prwlocktrywrlock.c
@@ -39,7 +39,6 @@ int pthread_rwlock_trywrlock(
     &the_rwlock->RWLock,
     _Thread_Executing,
     false,                 /* we are not willing to wait */
-    0,
     &queue_context
   );
   return _POSIX_Get_error( status );
diff --git a/cpukit/posix/src/prwlockwrlock.c b/cpukit/posix/src/prwlockwrlock.c
index 4592aaa04e..3f4df2de0a 100644
--- a/cpukit/posix/src/prwlockwrlock.c
+++ b/cpukit/posix/src/prwlockwrlock.c
@@ -39,11 +39,11 @@ int pthread_rwlock_wrlock(
     return EINVAL;
   }
 
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_NO_TIMEOUT );
   status = _CORE_RWLock_Seize_for_writing(
     &the_rwlock->RWLock,
     _Thread_Executing,
     true,          /* do not timeout -- wait forever */
-    0,
     &queue_context
   );
   return _POSIX_Get_error( status );
diff --git a/cpukit/posix/src/pthreadjoin.c b/cpukit/posix/src/pthreadjoin.c
index 86b805132a..9db24aea3c 100644
--- a/cpukit/posix/src/pthreadjoin.c
+++ b/cpukit/posix/src/pthreadjoin.c
@@ -40,6 +40,7 @@ static int _POSIX_Threads_Join( pthread_t thread, void **value_ptr )
 
   _Thread_queue_Context_initialize( &queue_context );
   _Thread_queue_Context_set_expected_level( &queue_context, 1 );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_NO_TIMEOUT );
   the_thread = _Thread_Get( thread, &queue_context.Lock_context );
 
   if ( the_thread == NULL ) {
diff --git a/cpukit/posix/src/semaphorewaitsupp.c b/cpukit/posix/src/semaphorewaitsupp.c
index 9ba8d55894..54fc8d5be3 100644
--- a/cpukit/posix/src/semaphorewaitsupp.c
+++ b/cpukit/posix/src/semaphorewaitsupp.c
@@ -41,12 +41,13 @@ int _POSIX_Semaphore_Wait_support(
     rtems_set_errno_and_return_minus_one( EINVAL );
   }
 
+  _Thread_queue_Context_set_timeout( &queue_context, timeout );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_RELATIVE );
   status = _CORE_semaphore_Seize(
     &the_semaphore->Semaphore,
     POSIX_SEMAPHORE_TQ_OPERATIONS,
     _Thread_Executing,
     blocking,
-    timeout,
     &queue_context
   );
   return _POSIX_Zero_or_minus_one_plus_errno( status );
diff --git a/cpukit/posix/src/sigtimedwait.c b/cpukit/posix/src/sigtimedwait.c
index 7855bb0080..6ea8d2fc0d 100644
--- a/cpukit/posix/src/sigtimedwait.c
+++ b/cpukit/posix/src/sigtimedwait.c
@@ -153,12 +153,13 @@ int sigtimedwait(
   executing->Wait.option          = *set;
   executing->Wait.return_argument = the_info;
   _Thread_queue_Context_set_expected_level( &queue_context, 1 );
+  _Thread_queue_Context_set_timeout( &queue_context, interval );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_RELATIVE );
   _Thread_queue_Enqueue_critical(
     &_POSIX_signals_Wait_queue.Queue,
     POSIX_SIGNALS_TQ_OPERATIONS,
     executing,
     STATES_WAITING_FOR_SIGNAL | STATES_INTERRUPTIBLE_BY_SIGNAL,
-    interval,
     &queue_context
   );
 
diff --git a/cpukit/posix/src/ualarm.c b/cpukit/posix/src/ualarm.c
index 86fe1b05cc..07bbdeaebb 100644
--- a/cpukit/posix/src/ualarm.c
+++ b/cpukit/posix/src/ualarm.c
@@ -55,9 +55,10 @@ static void _POSIX_signals_Ualarm_TSR( Watchdog_Control *the_watchdog )
    * If the reset interval is non-zero, reschedule ourselves.
    */
   if ( _POSIX_signals_Ualarm_interval != 0 ) {
-    _Watchdog_Per_CPU_insert_relative(
+    _Watchdog_Per_CPU_insert(
       the_watchdog,
       _Per_CPU_Get(),
+      WATCHDOG_RELATIVE,
       _POSIX_signals_Ualarm_interval
     );
   }
diff --git a/cpukit/rtems/src/barrierwait.c b/cpukit/rtems/src/barrierwait.c
index 5f1f023f50..c645aa18c4 100644
--- a/cpukit/rtems/src/barrierwait.c
+++ b/cpukit/rtems/src/barrierwait.c
@@ -38,11 +38,12 @@ rtems_status_code rtems_barrier_wait(
     return RTEMS_INVALID_ID;
   }
 
+  _Thread_queue_Context_set_timeout( &queue_context, timeout );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_RELATIVE );
   status = _CORE_barrier_Seize(
     &the_barrier->Barrier,
     _Thread_Executing,
     true,
-    timeout,
     &queue_context
   );
   return _Status_Get( status );
diff --git a/cpukit/rtems/src/eventseize.c b/cpukit/rtems/src/eventseize.c
index c91d308438..468e066ae5 100644
--- a/cpukit/rtems/src/eventseize.c
+++ b/cpukit/rtems/src/eventseize.c
@@ -81,11 +81,12 @@ rtems_status_code _Event_Seize(
   _Thread_Lock_release_default( executing, lock_context );
 
   if ( ticks ) {
-    _Thread_Timer_insert_relative(
+    _Thread_Timer_insert(
       executing,
       cpu_self,
       _Thread_Timeout,
-      ticks
+      ticks,
+      WATCHDOG_RELATIVE
     );
   }
 
diff --git a/cpukit/rtems/src/msgqreceive.c b/cpukit/rtems/src/msgqreceive.c
index 75c15beb6a..72c09555ce 100644
--- a/cpukit/rtems/src/msgqreceive.c
+++ b/cpukit/rtems/src/msgqreceive.c
@@ -61,13 +61,14 @@ rtems_status_code rtems_message_queue_receive(
   );
 
   executing = _Thread_Executing;
+  _Thread_queue_Context_set_timeout( &queue_context, timeout );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_RELATIVE );
   status = _CORE_message_queue_Seize(
     &the_message_queue->message_queue,
     executing,
     buffer,
     size,
     !_Options_Is_no_wait( option_set ),
-    timeout,
     &queue_context
   );
   return _Status_Get( status );
diff --git a/cpukit/rtems/src/msgqsend.c b/cpukit/rtems/src/msgqsend.c
index 7968281d59..1fab4b07a8 100644
--- a/cpukit/rtems/src/msgqsend.c
+++ b/cpukit/rtems/src/msgqsend.c
@@ -58,7 +58,6 @@ rtems_status_code rtems_message_queue_send(
     buffer,
     size,
     false,   /* sender does not block */
-    0,       /* no timeout */
     &queue_context
   );
   return _Status_Get( status );
diff --git a/cpukit/rtems/src/msgqurgent.c b/cpukit/rtems/src/msgqurgent.c
index 6c6379d7d8..4756da4a33 100644
--- a/cpukit/rtems/src/msgqurgent.c
+++ b/cpukit/rtems/src/msgqurgent.c
@@ -58,7 +58,6 @@ rtems_status_code rtems_message_queue_urgent(
     buffer,
     size,
     false,   /* sender does not block */
-    0,       /* no timeout */
     &queue_context
   );
   return _Status_Get( status );
diff --git a/cpukit/rtems/src/ratemonperiod.c b/cpukit/rtems/src/ratemonperiod.c
index 771f9c15ab..10a65f478b 100644
--- a/cpukit/rtems/src/ratemonperiod.c
+++ b/cpukit/rtems/src/ratemonperiod.c
@@ -77,9 +77,10 @@ static void _Rate_monotonic_Release_job(
   _Rate_monotonic_Release( owner, lock_context );
 
   _ISR_lock_ISR_disable( lock_context );
-  deadline = _Watchdog_Per_CPU_insert_relative(
+  deadline = _Watchdog_Per_CPU_insert(
     &the_period->Timer,
     cpu_self,
+    WATCHDOG_RELATIVE,
     next_length
   );
   _ISR_lock_ISR_enable( lock_context );
diff --git a/cpukit/rtems/src/regiongetsegment.c b/cpukit/rtems/src/regiongetsegment.c
index cfc664580c..ec0c52519b 100644
--- a/cpukit/rtems/src/regiongetsegment.c
+++ b/cpukit/rtems/src/regiongetsegment.c
@@ -87,6 +87,7 @@ rtems_status_code rtems_region_get_segment(
         executing,
         STATES_WAITING_FOR_SEGMENT,
         timeout,
+        WATCHDOG_RELATIVE,
         2
       );
 
diff --git a/cpukit/rtems/src/semobtain.c b/cpukit/rtems/src/semobtain.c
index 0e5330af41..d2771c48af 100644
--- a/cpukit/rtems/src/semobtain.c
+++ b/cpukit/rtems/src/semobtain.c
@@ -69,13 +69,15 @@ rtems_status_code rtems_semaphore_obtain(
   executing = _Thread_Executing;
   wait = !_Options_Is_no_wait( option_set );
 
+  _Thread_queue_Context_set_timeout( &queue_context, timeout );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_RELATIVE );
+
   switch ( the_semaphore->variant ) {
     case SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY:
       status = _CORE_recursive_mutex_Seize(
         &the_semaphore->Core_control.Mutex.Recursive,
         executing,
         wait,
-        timeout,
         _CORE_recursive_mutex_Seize_nested,
         &queue_context
       );
@@ -85,7 +87,6 @@ rtems_status_code rtems_semaphore_obtain(
         &the_semaphore->Core_control.Mutex,
         executing,
         wait,
-        timeout,
         _CORE_recursive_mutex_Seize_nested,
         &queue_context
       );
@@ -96,7 +97,6 @@ rtems_status_code rtems_semaphore_obtain(
         _Semaphore_Get_operations( the_semaphore ),
         executing,
         wait,
-        timeout,
         _CORE_recursive_mutex_Seize_nested,
         &queue_context
       );
@@ -107,7 +107,6 @@ rtems_status_code rtems_semaphore_obtain(
         &the_semaphore->Core_control.MRSP,
         executing,
         wait,
-        timeout,
         &queue_context
       );
       break;
@@ -122,7 +121,6 @@ rtems_status_code rtems_semaphore_obtain(
         _Semaphore_Get_operations( the_semaphore ),
         executing,
         wait,
-        timeout,
         &queue_context
       );
       break;
diff --git a/cpukit/rtems/src/taskwakeafter.c b/cpukit/rtems/src/taskwakeafter.c
index fa5f6f4eed..c1a823476d 100644
--- a/cpukit/rtems/src/taskwakeafter.c
+++ b/cpukit/rtems/src/taskwakeafter.c
@@ -41,11 +41,12 @@ rtems_status_code rtems_task_wake_after(
     } else {
       _Thread_Set_state( executing, STATES_DELAYING );
       _Thread_Wait_flags_set( executing, THREAD_WAIT_STATE_BLOCKED );
-      _Thread_Timer_insert_relative(
+      _Thread_Timer_insert(
         executing,
         cpu_self,
         _Thread_Timeout,
-        ticks
+        ticks,
+        WATCHDOG_RELATIVE
       );
     }
   _Thread_Dispatch_enable( cpu_self );
diff --git a/cpukit/rtems/src/taskwakewhen.c b/cpukit/rtems/src/taskwakewhen.c
index 5d6d45afcf..6b76d3eeb3 100644
--- a/cpukit/rtems/src/taskwakewhen.c
+++ b/cpukit/rtems/src/taskwakewhen.c
@@ -52,11 +52,12 @@ rtems_status_code rtems_task_wake_when(
     executing = _Thread_Executing;
     _Thread_Set_state( executing, STATES_WAITING_FOR_TIME );
     _Thread_Wait_flags_set( executing, THREAD_WAIT_STATE_BLOCKED );
-    _Thread_Timer_insert_absolute(
+    _Thread_Timer_insert(
       executing,
       cpu_self,
       _Thread_Timeout,
-      _Watchdog_Ticks_from_seconds( seconds )
+      _Watchdog_Ticks_from_seconds( seconds ),
+      WATCHDOG_ABSOLUTE
     );
   _Thread_Dispatch_enable( cpu_self );
   return RTEMS_SUCCESSFUL;
diff --git a/cpukit/score/include/rtems/score/corebarrierimpl.h b/cpukit/score/include/rtems/score/corebarrierimpl.h
index d2d9997d95..a7256b9d6d 100644
--- a/cpukit/score/include/rtems/score/corebarrierimpl.h
+++ b/cpukit/score/include/rtems/score/corebarrierimpl.h
@@ -87,10 +87,6 @@ RTEMS_INLINE_ROUTINE void _CORE_barrier_Release(
  *  @param[in] the_barrier is the barrier to wait for
  *  @param[in,out] executing The currently executing thread.
  *  @param[in] wait is true if the calling thread is willing to wait
- *  @param[in] timeout is the number of ticks the calling thread is willing
- *         to wait if @a wait is true.
- *  @param[in] mp_callout is the routine to invoke if the
- *         thread unblocked is remote
  *
  * @return The method status.
  */
@@ -98,7 +94,6 @@ Status_Control _CORE_barrier_Seize(
   CORE_barrier_Control *the_barrier,
   Thread_Control       *executing,
   bool                  wait,
-  Watchdog_Interval     timeout,
   Thread_queue_Context *queue_context
 );
 
diff --git a/cpukit/score/include/rtems/score/coremsgimpl.h b/cpukit/score/include/rtems/score/coremsgimpl.h
index d240c4a405..3b811c920d 100644
--- a/cpukit/score/include/rtems/score/coremsgimpl.h
+++ b/cpukit/score/include/rtems/score/coremsgimpl.h
@@ -194,8 +194,6 @@ Status_Control _CORE_message_queue_Broadcast(
  *         appended, or enqueued in priority order.
  *  @param[in] wait indicates whether the calling thread is willing to block
  *         if the message queue is full.
- *  @param[in] timeout is the maximum number of clock ticks that the calling
- *         thread is willing to block if the message queue is full.
  *  @param[in] queue_context The thread queue context used for
  *    _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical().
  *  @retval indication of the successful completion or reason for failure
@@ -207,7 +205,6 @@ Status_Control _CORE_message_queue_Submit(
   size_t                            size,
   CORE_message_queue_Submit_types   submit_type,
   bool                              wait,
-  Watchdog_Interval                 timeout,
   Thread_queue_Context             *queue_context
 );
 
@@ -230,8 +227,6 @@ Status_Control _CORE_message_queue_Submit(
  *         indicates the maximum size message that the caller can receive.
  *  @param[in] wait indicates whether the calling thread is willing to block
  *         if the message queue is empty.
- *  @param[in] timeout is the maximum number of clock ticks that the calling
- *         thread is willing to block if the message queue is empty.
  *  @param[in] queue_context The thread queue context used for
  *    _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical().
  *
@@ -251,7 +246,6 @@ Status_Control _CORE_message_queue_Seize(
   void                       *buffer,
   size_t                     *size_p,
   bool                        wait,
-  Watchdog_Interval           timeout,
   Thread_queue_Context       *queue_context
 );
 
@@ -281,7 +275,6 @@ RTEMS_INLINE_ROUTINE Status_Control _CORE_message_queue_Send(
   const void                       *buffer,
   size_t                            size,
   bool                              wait,
-  Watchdog_Interval                 timeout,
   Thread_queue_Context             *queue_context
 )
 {
@@ -292,7 +285,6 @@ RTEMS_INLINE_ROUTINE Status_Control _CORE_message_queue_Send(
     size,
     CORE_MESSAGE_QUEUE_SEND_REQUEST,
     wait,
-    timeout,
     queue_context
   );
 }
@@ -302,7 +294,6 @@ RTEMS_INLINE_ROUTINE Status_Control _CORE_message_queue_Urgent(
   const void                       *buffer,
   size_t                            size,
   bool                              wait,
-  Watchdog_Interval                 timeout,
   Thread_queue_Context             *queue_context
 )
 {
@@ -313,7 +304,6 @@ RTEMS_INLINE_ROUTINE Status_Control _CORE_message_queue_Urgent(
     size,
     CORE_MESSAGE_QUEUE_URGENT_REQUEST,
     wait,
-    timeout,
     queue_context
   );
 }
diff --git a/cpukit/score/include/rtems/score/coremuteximpl.h b/cpukit/score/include/rtems/score/coremuteximpl.h
index 3a5ae99a95..339834bc37 100644
--- a/cpukit/score/include/rtems/score/coremuteximpl.h
+++ b/cpukit/score/include/rtems/score/coremuteximpl.h
@@ -100,7 +100,6 @@ Status_Control _CORE_mutex_Seize_slow(
   Thread_Control       *executing,
   Thread_Control       *owner,
   bool                  wait,
-  Watchdog_Interval     timeout,
   Thread_queue_Context *queue_context
 );
 
@@ -109,7 +108,6 @@ Status_Control _CORE_mutex_Seize_no_protocol_slow(
   const Thread_queue_Operations *operations,
   Thread_Control                *executing,
   bool                           wait,
-  Watchdog_Interval              timeout,
   Thread_queue_Context          *queue_context
 );
 
@@ -183,7 +181,6 @@ RTEMS_INLINE_ROUTINE Status_Control _CORE_recursive_mutex_Seize(
   CORE_recursive_mutex_Control  *the_mutex,
   Thread_Control                *executing,
   bool                           wait,
-  Watchdog_Interval              timeout,
   Status_Control              ( *nested )( CORE_recursive_mutex_Control * ),
   Thread_queue_Context          *queue_context
 )
@@ -214,7 +211,6 @@ RTEMS_INLINE_ROUTINE Status_Control _CORE_recursive_mutex_Seize(
     executing,
     owner,
     wait,
-    timeout,
     queue_context
   );
 }
@@ -277,7 +273,6 @@ RTEMS_INLINE_ROUTINE Status_Control _CORE_recursive_mutex_Seize_no_protocol(
   const Thread_queue_Operations *operations,
   Thread_Control                *executing,
   bool                           wait,
-  Watchdog_Interval              timeout,
   Status_Control              ( *nested )( CORE_recursive_mutex_Control * ),
   Thread_queue_Context          *queue_context
 )
@@ -307,7 +302,6 @@ RTEMS_INLINE_ROUTINE Status_Control _CORE_recursive_mutex_Seize_no_protocol(
     operations,
     executing,
     wait,
-    timeout,
     queue_context
   );
 }
@@ -434,7 +428,6 @@ RTEMS_INLINE_ROUTINE Status_Control _CORE_ceiling_mutex_Seize(
   CORE_ceiling_mutex_Control    *the_mutex,
   Thread_Control                *executing,
   bool                           wait,
-  Watchdog_Interval              timeout,
   Status_Control              ( *nested )( CORE_recursive_mutex_Control * ),
   Thread_queue_Context          *queue_context
 )
@@ -476,7 +469,6 @@ RTEMS_INLINE_ROUTINE Status_Control _CORE_ceiling_mutex_Seize(
     CORE_MUTEX_TQ_OPERATIONS,
     executing,
     wait,
-    timeout,
     queue_context
   );
 }
diff --git a/cpukit/score/include/rtems/score/corerwlockimpl.h b/cpukit/score/include/rtems/score/corerwlockimpl.h
index e80ab0ef0c..ff881fa186 100644
--- a/cpukit/score/include/rtems/score/corerwlockimpl.h
+++ b/cpukit/score/include/rtems/score/corerwlockimpl.h
@@ -95,15 +95,12 @@ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Release(
  *
  *  @param[in] the_rwlock is the RWLock to wait for
  *  @param[in] wait is true if the calling thread is willing to wait
- *  @param[in] timeout is the number of ticks the calling thread is willing
- *         to wait if @a wait is true.
  */
 
 Status_Control _CORE_RWLock_Seize_for_reading(
   CORE_RWLock_Control  *the_rwlock,
   Thread_Control       *executing,
   bool                  wait,
-  Watchdog_Interval     timeout,
   Thread_queue_Context *queue_context
 );
 
@@ -114,14 +111,11 @@ Status_Control _CORE_RWLock_Seize_for_reading(
  *
  *  @param[in] the_rwlock is the RWLock to wait for
  *  @param[in] wait is true if the calling thread is willing to wait
- *  @param[in] timeout is the number of ticks the calling thread is willing
- *         to wait if @a wait is true.
  */
 Status_Control _CORE_RWLock_Seize_for_writing(
   CORE_RWLock_Control  *the_rwlock,
   Thread_Control       *executing,
   bool                  wait,
-  Watchdog_Interval     timeout,
   Thread_queue_Context *queue_context
 );
 
diff --git a/cpukit/score/include/rtems/score/coresemimpl.h b/cpukit/score/include/rtems/score/coresemimpl.h
index 487a91b3c7..5a287263aa 100644
--- a/cpukit/score/include/rtems/score/coresemimpl.h
+++ b/cpukit/score/include/rtems/score/coresemimpl.h
@@ -165,7 +165,6 @@ RTEMS_INLINE_ROUTINE uint32_t  _CORE_semaphore_Get_count(
  * @param[in] operations The thread queue operations.
  * @param[in] executing The currently executing thread.
  * @param[in] wait is true if the thread is willing to wait
- * @param[in] timeout is the maximum number of ticks to block
  * @param[in] queue_context is a temporary variable used to contain the ISR
  *        disable level cookie
  */
@@ -174,7 +173,6 @@ RTEMS_INLINE_ROUTINE Status_Control _CORE_semaphore_Seize(
   const Thread_queue_Operations *operations,
   Thread_Control                *executing,
   bool                           wait,
-  Watchdog_Interval              timeout,
   Thread_queue_Context          *queue_context
 )
 {
@@ -198,7 +196,6 @@ RTEMS_INLINE_ROUTINE Status_Control _CORE_semaphore_Seize(
     operations,
     executing,
     STATES_WAITING_FOR_SEMAPHORE,
-    timeout,
     queue_context
   );
   return _Thread_Wait_get_status( executing );
diff --git a/cpukit/score/include/rtems/score/mrspimpl.h b/cpukit/score/include/rtems/score/mrspimpl.h
index 66f5cc6640..2bf9620e45 100644
--- a/cpukit/score/include/rtems/score/mrspimpl.h
+++ b/cpukit/score/include/rtems/score/mrspimpl.h
@@ -240,7 +240,6 @@ RTEMS_INLINE_ROUTINE Status_Control _MRSP_Wait_for_ownership(
   Thread_Control       *executing,
   Priority_Control      initial_priority,
   Priority_Control      ceiling_priority,
-  Watchdog_Interval     timeout,
   Thread_queue_Context *queue_context
 )
 {
@@ -250,6 +249,8 @@ RTEMS_INLINE_ROUTINE Status_Control _MRSP_Wait_for_ownership(
   Per_CPU_Control *cpu_self;
   ISR_lock_Context giant_lock_context;
   ISR_Level level;
+  Watchdog_Interval timeout = queue_context->timeout;
+  Watchdog_Discipline discipline = queue_context->timeout_discipline;
 
   rival.thread = executing;
   rival.resource = mrsp;
@@ -280,7 +281,12 @@ RTEMS_INLINE_ROUTINE Status_Control _MRSP_Wait_for_ownership(
     _Watchdog_Preinitialize( &rival.Watchdog, cpu_self );
     _Watchdog_Initialize( &rival.Watchdog, _MRSP_Timeout );
     _ISR_Local_disable( level );
-    _Watchdog_Per_CPU_insert_relative( &rival.Watchdog, cpu_self, timeout );
+    _Watchdog_Per_CPU_insert(
+      &rival.Watchdog,
+      cpu_self,
+      discipline,
+      timeout
+    );
     _ISR_Local_enable( level );
   }
 
@@ -317,7 +323,6 @@ RTEMS_INLINE_ROUTINE Status_Control _MRSP_Seize(
   MRSP_Control         *mrsp,
   Thread_Control       *executing,
   bool                  wait,
-  Watchdog_Interval     timeout,
   Thread_queue_Context *queue_context
 )
 {
@@ -357,7 +362,6 @@ RTEMS_INLINE_ROUTINE Status_Control _MRSP_Seize(
       executing,
       initial_priority,
       ceiling_priority,
-      timeout,
       queue_context
     );
   } else {
diff --git a/cpukit/score/include/rtems/score/threadimpl.h b/cpukit/score/include/rtems/score/threadimpl.h
index 6bb78158e3..b09e7ddac6 100644
--- a/cpukit/score/include/rtems/score/threadimpl.h
+++ b/cpukit/score/include/rtems/score/threadimpl.h
@@ -1466,38 +1466,26 @@ RTEMS_INLINE_ROUTINE void _Thread_Timer_initialize(
   _Watchdog_Preinitialize( &timer->Watchdog, cpu );
 }
 
-RTEMS_INLINE_ROUTINE void _Thread_Timer_insert_relative(
+RTEMS_INLINE_ROUTINE void _Thread_Timer_insert(
   Thread_Control                 *the_thread,
   Per_CPU_Control                *cpu,
   Watchdog_Service_routine_entry  routine,
-  Watchdog_Interval               ticks
+  uint64_t                        ticks,
+  Watchdog_Discipline             discipline
 )
 {
   ISR_lock_Context lock_context;
 
   _ISR_lock_ISR_disable_and_acquire( &the_thread->Timer.Lock, &lock_context );
 
-  the_thread->Timer.header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ];
-  the_thread->Timer.Watchdog.routine = routine;
-  _Watchdog_Per_CPU_insert_relative( &the_thread->Timer.Watchdog, cpu, ticks );
-
-  _ISR_lock_Release_and_ISR_enable( &the_thread->Timer.Lock, &lock_context );
-}
-
-RTEMS_INLINE_ROUTINE void _Thread_Timer_insert_absolute(
-  Thread_Control                 *the_thread,
-  Per_CPU_Control                *cpu,
-  Watchdog_Service_routine_entry  routine,
-  uint64_t                        expire
-)
-{
-  ISR_lock_Context lock_context;
-
-  _ISR_lock_ISR_disable_and_acquire( &the_thread->Timer.Lock, &lock_context );
-
-  the_thread->Timer.header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_ABSOLUTE ];
+  if ( discipline == WATCHDOG_RELATIVE ) {
+    the_thread->Timer.header = &cpu->Watchdog.Header[PER_CPU_WATCHDOG_RELATIVE];
+  } else {
+    _Assert( discipline == WATCHDOG_ABSOLUTE );
+    the_thread->Timer.header = &cpu->Watchdog.Header[PER_CPU_WATCHDOG_ABSOLUTE];
+  }
   the_thread->Timer.Watchdog.routine = routine;
-  _Watchdog_Per_CPU_insert_absolute( &the_thread->Timer.Watchdog, cpu, expire );
+  _Watchdog_Per_CPU_insert( &the_thread->Timer.Watchdog, cpu, discipline, ticks );
 
   _ISR_lock_Release_and_ISR_enable( &the_thread->Timer.Lock, &lock_context );
 }
diff --git a/cpukit/score/include/rtems/score/threadq.h b/cpukit/score/include/rtems/score/threadq.h
index a4e5292f34..79cc4c67f0 100644
--- a/cpukit/score/include/rtems/score/threadq.h
+++ b/cpukit/score/include/rtems/score/threadq.h
@@ -24,6 +24,7 @@
 #include <rtems/score/object.h>
 #include <rtems/score/priority.h>
 #include <rtems/score/rbtree.h>
+#include <rtems/score/watchdog.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -79,6 +80,17 @@ typedef struct {
   uint32_t expected_thread_dispatch_disable_level;
 
   /**
+   * @brief Interval to wait.
+   */
+  Watchdog_Interval timeout;
+
+  /**
+   * @brief The clock discipline for the interval timeout.
+   * Use WATCHDOG_NO_TIMEOUT to block indefinitely.
+   */
+  Watchdog_Discipline timeout_discipline;
+
+  /**
    * @brief Callout to unblock the thread in case it is actually a thread
    * proxy.
    *
diff --git a/cpukit/score/include/rtems/score/threadqimpl.h b/cpukit/score/include/rtems/score/threadqimpl.h
index 73d4de2032..dde3d27a6d 100644
--- a/cpukit/score/include/rtems/score/threadqimpl.h
+++ b/cpukit/score/include/rtems/score/threadqimpl.h
@@ -91,6 +91,40 @@ _Thread_queue_Context_set_expected_level(
 }
 
 /**
+ * @brief Sets the timeout interval in the thread queue context.
+ *
+ * @param queue_context The thread queue context.
+ * @param timeout The new timeout.
+ *
+ * @see _Thread_queue_Enqueue_critical().
+ */
+RTEMS_INLINE_ROUTINE void
+_Thread_queue_Context_set_timeout(
+  Thread_queue_Context *queue_context,
+  Watchdog_Interval     timeout
+)
+{
+  queue_context->timeout = timeout;
+}
+
+/**
+ * @brief Sets the clock discipline for the timeout in the thread queue context.
+ *
+ * @param queue_context The thread queue context.
+ * @param discipline The clock discipline to use for the timeout.
+ *
+ * @see _Thread_queue_Enqueue_critical().
+ */
+RTEMS_INLINE_ROUTINE void
+_Thread_queue_Context_set_discipline(
+  Thread_queue_Context *queue_context,
+  Watchdog_Discipline   discipline
+)
+{
+  queue_context->timeout_discipline = discipline;
+}
+
+/**
  * @brief Sets the MP callout in the thread queue context.
  *
  * @param queue_context The thread queue context.
@@ -305,8 +339,8 @@ Thread_Control *_Thread_queue_Do_dequeue(
  * @brief Blocks the thread and places it on the thread queue.
  *
  * This enqueues the thread on the thread queue, blocks the thread, and
- * optionally starts the thread timer in case the timeout interval is not
- * WATCHDOG_NO_TIMEOUT.
+ * optionally starts the thread timer in case the timeout discipline is not
+ * WATCHDOG_NO_TIMEOUT. Timeout discipline and value are in the queue_context.
  *
  * The caller must be the owner of the thread queue lock.  This function will
  * release the thread queue lock and register it as the new thread lock.
@@ -348,7 +382,6 @@ Thread_Control *_Thread_queue_Do_dequeue(
  *       MUTEX_TQ_OPERATIONS,
  *       executing,
  *       STATES_WAITING_FOR_MUTEX,
- *       WATCHDOG_NO_TIMEOUT,
  *       0,
  *       &queue_context
  *     );
@@ -360,8 +393,6 @@ Thread_Control *_Thread_queue_Do_dequeue(
  * @param[in] operations The thread queue operations.
  * @param[in] the_thread The thread to enqueue.
  * @param[in] state The new state of the thread.
- * @param[in] timeout Interval to wait.  Use WATCHDOG_NO_TIMEOUT to block
- * potentially forever.
  * @param[in] queue_context The thread queue context of the lock acquire.
  */
 void _Thread_queue_Enqueue_critical(
@@ -369,7 +400,6 @@ void _Thread_queue_Enqueue_critical(
   const Thread_queue_Operations *operations,
   Thread_Control                *the_thread,
   States_Control                 state,
-  Watchdog_Interval              timeout,
   Thread_queue_Context          *queue_context
 );
 
@@ -383,6 +413,7 @@ RTEMS_INLINE_ROUTINE void _Thread_queue_Enqueue(
   Thread_Control                *the_thread,
   States_Control                 state,
   Watchdog_Interval              timeout,
+  Watchdog_Discipline            discipline,
   uint32_t                       expected_level
 )
 {
@@ -391,12 +422,13 @@ RTEMS_INLINE_ROUTINE void _Thread_queue_Enqueue(
   _Thread_queue_Context_initialize( &queue_context );
   _Thread_queue_Acquire( the_thread_queue, &queue_context.Lock_context );
   _Thread_queue_Context_set_expected_level( &queue_context, expected_level );
+  _Thread_queue_Context_set_timeout( &queue_context, timeout );
+  _Thread_queue_Context_set_discipline( &queue_context, discipline );
   _Thread_queue_Enqueue_critical(
     &the_thread_queue->Queue,
     operations,
     the_thread,
     state,
-    timeout,
     &queue_context
   );
 }
diff --git a/cpukit/score/include/rtems/score/watchdog.h b/cpukit/score/include/rtems/score/watchdog.h
index c582dbd1ae..11a5974c26 100644
--- a/cpukit/score/include/rtems/score/watchdog.h
+++ b/cpukit/score/include/rtems/score/watchdog.h
@@ -53,6 +53,38 @@ typedef struct Watchdog_Control Watchdog_Control;
 typedef uint32_t   Watchdog_Interval;
 
 /**
+ *  @brief The clock discipline to use for the Watchdog timeout interval.
+ */
+typedef enum {
+
+  /**
+   * @brief Indefinite wait.
+   *
+   * This is to indicate there is no timeout and not to use a watchdog. It
+   * must be equal to 0, which is an illegal relative clock interval, so that
+   * it may be used as a Watchdog_Interval value with WATCHDOG_RELATIVE to
+   * express an indefinite wait.
+   */
+  WATCHDOG_NO_TIMEOUT = 0,
+
+  /**
+   * @brief Relative clock.
+   *
+   * The reference time point for the watchdog is current ticks value
+   * during insert.  Time is measured in clock ticks.
+   */
+  WATCHDOG_RELATIVE,
+
+  /**
+   * @brief Absolute clock.
+   *
+   * The reference time point for this header is the POSIX Epoch.  Time is
+   * measured in nanoseconds since POSIX Epoch.
+   */
+  WATCHDOG_ABSOLUTE
+} Watchdog_Discipline;
+
+/**
  *  @brief Return type from a Watchdog Service Routine.
  *
  *  This type defines the return type from a Watchdog Service Routine.
@@ -68,14 +100,6 @@ typedef Watchdog_Service_routine
   ( *Watchdog_Service_routine_entry )( Watchdog_Control * );
 
 /**
- *  @brief The constant for indefinite wait.
- *
- *  This is the constant for indefinite wait.  It is actually an
- *  illegal interval.
- */
-#define WATCHDOG_NO_TIMEOUT  0
-
-/**
  * @brief The watchdog header to manage scheduled watchdogs.
  */
 typedef struct {
diff --git a/cpukit/score/include/rtems/score/watchdogimpl.h b/cpukit/score/include/rtems/score/watchdogimpl.h
index b76a51acfa..9ba30a55a0 100644
--- a/cpukit/score/include/rtems/score/watchdogimpl.h
+++ b/cpukit/score/include/rtems/score/watchdogimpl.h
@@ -339,46 +339,36 @@ RTEMS_INLINE_ROUTINE void _Watchdog_Per_CPU_release_critical(
   _ISR_lock_Release( &cpu->Watchdog.Lock, lock_context );
 }
 
-RTEMS_INLINE_ROUTINE uint64_t _Watchdog_Per_CPU_insert_relative(
-  Watchdog_Control *the_watchdog,
-  Per_CPU_Control  *cpu,
-  uint32_t          ticks
+RTEMS_INLINE_ROUTINE uint64_t _Watchdog_Per_CPU_insert(
+  Watchdog_Control    *the_watchdog,
+  Per_CPU_Control     *cpu,
+  Watchdog_Discipline  discipline,
+  uint64_t             ticks
 )
 {
   ISR_lock_Context lock_context;
-  uint64_t expire;
+  Watchdog_Header *header;
 
   _Watchdog_Set_CPU( the_watchdog, cpu );
 
   _Watchdog_Per_CPU_acquire_critical( cpu, &lock_context );
-  expire = cpu->Watchdog.ticks + ticks;
-  _Watchdog_Insert(
-    &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ],
-    the_watchdog,
-    expire
-  );
-  _Watchdog_Per_CPU_release_critical( cpu, &lock_context );
-
-  return expire;
-}
-
-RTEMS_INLINE_ROUTINE void _Watchdog_Per_CPU_insert_absolute(
-  Watchdog_Control *the_watchdog,
-  Per_CPU_Control  *cpu,
-  uint64_t          expire
-)
-{
-  ISR_lock_Context lock_context;
 
-  _Watchdog_Set_CPU( the_watchdog, cpu );
+  switch ( discipline ) {
+    case WATCHDOG_RELATIVE:
+      ticks += cpu->Watchdog.ticks;
+      header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ];
+      break;
+    case WATCHDOG_ABSOLUTE:
+      header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_ABSOLUTE ];
+      break;
+    default:
+      _Assert(0);
+      break;
+  }
 
-  _Watchdog_Per_CPU_acquire_critical( cpu, &lock_context );
-  _Watchdog_Insert(
-    &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_ABSOLUTE ],
-    the_watchdog,
-    expire
-  );
+  _Watchdog_Insert(header, the_watchdog, ticks);
   _Watchdog_Per_CPU_release_critical( cpu, &lock_context );
+  return ticks;
 }
 
 RTEMS_INLINE_ROUTINE void _Watchdog_Per_CPU_remove(
diff --git a/cpukit/score/src/apimutexlock.c b/cpukit/score/src/apimutexlock.c
index df53e75256..1b452e8655 100644
--- a/cpukit/score/src/apimutexlock.c
+++ b/cpukit/score/src/apimutexlock.c
@@ -33,12 +33,11 @@ void _API_Mutex_Lock( API_Mutex_Control *the_mutex )
 
   _Thread_queue_Context_initialize( &queue_context );
   _ISR_lock_ISR_disable( &queue_context.Lock_context );
-
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_NO_TIMEOUT );
   _CORE_recursive_mutex_Seize(
     &the_mutex->Mutex,
     _Thread_Executing,
     true,
-    WATCHDOG_NO_TIMEOUT,
     _CORE_recursive_mutex_Seize_nested,
     &queue_context
   );
diff --git a/cpukit/score/src/condition.c b/cpukit/score/src/condition.c
index e7d98058a0..c388d9482d 100644
--- a/cpukit/score/src/condition.c
+++ b/cpukit/score/src/condition.c
@@ -82,7 +82,6 @@ static void _Condition_Queue_release(
 
 static Per_CPU_Control *_Condition_Do_wait(
   struct _Condition_Control *_condition,
-  Watchdog_Interval          timeout,
   Thread_queue_Context      *queue_context
 )
 {
@@ -100,7 +99,6 @@ static Per_CPU_Control *_Condition_Do_wait(
     CONDITION_TQ_OPERATIONS,
     executing,
     STATES_WAITING_FOR_SYS_LOCK_CONDITION,
-    timeout,
     queue_context
   );
 
@@ -117,7 +115,11 @@ void _Condition_Wait(
 
   _Thread_queue_Context_initialize( &queue_context );
   _ISR_lock_ISR_disable( &queue_context.Lock_context );
-  cpu_self = _Condition_Do_wait( _condition, 0, &queue_context );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_NO_TIMEOUT );
+  cpu_self = _Condition_Do_wait(
+    _condition,
+    &queue_context
+  );
 
   _Mutex_Release( _mutex );
   _Thread_Dispatch_enable( cpu_self );
@@ -151,7 +153,9 @@ int _Condition_Wait_timed(
       break;
   }
 
-  cpu_self = _Condition_Do_wait( _condition, ticks, &queue_context );
+  _Thread_queue_Context_set_timeout( &queue_context, ticks );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_RELATIVE );
+  cpu_self = _Condition_Do_wait( _condition, &queue_context );
 
   _Mutex_Release( _mutex );
   executing = cpu_self->executing;
@@ -173,7 +177,8 @@ void _Condition_Wait_recursive(
 
   _Thread_queue_Context_initialize( &queue_context );
   _ISR_lock_ISR_disable( &queue_context.Lock_context );
-  cpu_self = _Condition_Do_wait( _condition, 0, &queue_context );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_NO_TIMEOUT );
+  cpu_self = _Condition_Do_wait( _condition, &queue_context );
 
   nest_level = _mutex->_nest_level;
   _mutex->_nest_level = 0;
@@ -211,7 +216,9 @@ int _Condition_Wait_recursive_timed(
       break;
   }
 
-  cpu_self = _Condition_Do_wait( _condition, ticks, &queue_context );
+  _Thread_queue_Context_set_timeout( &queue_context, ticks );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_RELATIVE );
+  cpu_self = _Condition_Do_wait( _condition, &queue_context );
 
   nest_level = _mutex->_nest_level;
   _mutex->_nest_level = 0;
diff --git a/cpukit/score/src/corebarrierwait.c b/cpukit/score/src/corebarrierwait.c
index d939acf69b..7e46c93670 100644
--- a/cpukit/score/src/corebarrierwait.c
+++ b/cpukit/score/src/corebarrierwait.c
@@ -26,7 +26,6 @@ Status_Control _CORE_barrier_Seize(
   CORE_barrier_Control *the_barrier,
   Thread_Control       *executing,
   bool                  wait,
-  Watchdog_Interval     timeout,
   Thread_queue_Context *queue_context
 )
 {
@@ -51,7 +50,6 @@ Status_Control _CORE_barrier_Seize(
       CORE_BARRIER_TQ_OPERATIONS,
       executing,
       STATES_WAITING_FOR_BARRIER,
-      timeout,
       queue_context
     );
     return _Thread_Wait_get_status( executing );
diff --git a/cpukit/score/src/coremsgseize.c b/cpukit/score/src/coremsgseize.c
index 6906328039..d86afd08de 100644
--- a/cpukit/score/src/coremsgseize.c
+++ b/cpukit/score/src/coremsgseize.c
@@ -31,7 +31,6 @@ Status_Control _CORE_message_queue_Seize(
   void                       *buffer,
   size_t                     *size_p,
   bool                        wait,
-  Watchdog_Interval           timeout,
   Thread_queue_Context       *queue_context
 )
 {
@@ -120,7 +119,6 @@ Status_Control _CORE_message_queue_Seize(
     the_message_queue->operations,
     executing,
     STATES_WAITING_FOR_MESSAGE,
-    timeout,
     queue_context
   );
   return _Thread_Wait_get_status( executing );
diff --git a/cpukit/score/src/coremsgsubmit.c b/cpukit/score/src/coremsgsubmit.c
index fb56ffed4a..97b43823c3 100644
--- a/cpukit/score/src/coremsgsubmit.c
+++ b/cpukit/score/src/coremsgsubmit.c
@@ -33,7 +33,6 @@ Status_Control _CORE_message_queue_Submit(
   size_t                            size,
   CORE_message_queue_Submit_types   submit_type,
   bool                              wait,
-  Watchdog_Interval                 timeout,
   Thread_queue_Context             *queue_context
 )
 {
@@ -138,7 +137,6 @@ Status_Control _CORE_message_queue_Submit(
       the_message_queue->operations,
       executing,
       STATES_WAITING_FOR_MESSAGE,
-      timeout,
       queue_context
     );
     return _Thread_Wait_get_status( executing );
diff --git a/cpukit/score/src/coremutexseize.c b/cpukit/score/src/coremutexseize.c
index ab743c4847..c468c07a7c 100644
--- a/cpukit/score/src/coremutexseize.c
+++ b/cpukit/score/src/coremutexseize.c
@@ -21,13 +21,13 @@
 #include <rtems/score/coremuteximpl.h>
 #include <rtems/score/statesimpl.h>
 #include <rtems/score/thread.h>
+#include <rtems/score/watchdog.h>
 
 Status_Control _CORE_mutex_Seize_slow(
   CORE_mutex_Control   *the_mutex,
   Thread_Control       *executing,
   Thread_Control       *owner,
   bool                  wait,
-  Watchdog_Interval     timeout,
   Thread_queue_Context *queue_context
 )
 {
@@ -69,7 +69,6 @@ Status_Control _CORE_mutex_Seize_slow(
     CORE_MUTEX_TQ_OPERATIONS,
     executing,
     STATES_WAITING_FOR_MUTEX,
-    timeout,
     queue_context
   );
 
@@ -85,7 +84,6 @@ Status_Control _CORE_mutex_Seize_no_protocol_slow(
   const Thread_queue_Operations *operations,
   Thread_Control                *executing,
   bool                           wait,
-  Watchdog_Interval              timeout,
   Thread_queue_Context          *queue_context
 )
 {
@@ -96,7 +94,6 @@ Status_Control _CORE_mutex_Seize_no_protocol_slow(
       operations,
       executing,
       STATES_WAITING_FOR_MUTEX,
-      timeout,
       queue_context
     );
     return _Thread_Wait_get_status( executing );
diff --git a/cpukit/score/src/corerwlockobtainread.c b/cpukit/score/src/corerwlockobtainread.c
index bce992c1b0..09b26afd27 100644
--- a/cpukit/score/src/corerwlockobtainread.c
+++ b/cpukit/score/src/corerwlockobtainread.c
@@ -28,7 +28,6 @@ Status_Control _CORE_RWLock_Seize_for_reading(
   CORE_RWLock_Control  *the_rwlock,
   Thread_Control       *executing,
   bool                  wait,
-  Watchdog_Interval     timeout,
   Thread_queue_Context *queue_context
 )
 {
@@ -85,7 +84,6 @@ Status_Control _CORE_RWLock_Seize_for_reading(
      CORE_RWLOCK_TQ_OPERATIONS,
      executing,
      STATES_WAITING_FOR_RWLOCK,
-     timeout,
      queue_context
   );
   return _Thread_Wait_get_status( executing );
diff --git a/cpukit/score/src/corerwlockobtainwrite.c b/cpukit/score/src/corerwlockobtainwrite.c
index c261d32f3f..9aac5e7ef7 100644
--- a/cpukit/score/src/corerwlockobtainwrite.c
+++ b/cpukit/score/src/corerwlockobtainwrite.c
@@ -28,7 +28,6 @@ Status_Control _CORE_RWLock_Seize_for_writing(
   CORE_RWLock_Control  *the_rwlock,
   Thread_Control       *executing,
   bool                  wait,
-  Watchdog_Interval     timeout,
   Thread_queue_Context *queue_context
 )
 {
@@ -73,7 +72,6 @@ Status_Control _CORE_RWLock_Seize_for_writing(
      CORE_RWLOCK_TQ_OPERATIONS,
      executing,
      STATES_WAITING_FOR_RWLOCK,
-     timeout,
      queue_context
   );
   return _Thread_Wait_get_status( executing );
diff --git a/cpukit/score/src/futex.c b/cpukit/score/src/futex.c
index a192509f5c..55543f356f 100644
--- a/cpukit/score/src/futex.c
+++ b/cpukit/score/src/futex.c
@@ -89,12 +89,12 @@ int _Futex_Wait( struct _Futex_Control *_futex, int *uaddr, int val )
 
   if ( *uaddr == val ) {
     _Thread_queue_Context_set_expected_level( &queue_context, 1 );
+    _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_NO_TIMEOUT );
     _Thread_queue_Enqueue_critical(
       &futex->Queue.Queue,
       FUTEX_TQ_OPERATIONS,
       executing,
       STATES_WAITING_FOR_SYS_LOCK_FUTEX,
-      WATCHDOG_NO_TIMEOUT,
       &queue_context
     );
     eno = 0;
diff --git a/cpukit/score/src/mpci.c b/cpukit/score/src/mpci.c
index 9eb169ba17..2d2f9faee0 100644
--- a/cpukit/score/src/mpci.c
+++ b/cpukit/score/src/mpci.c
@@ -261,6 +261,7 @@ Status_Control _MPCI_Send_request_packet(
       executing,
       STATES_WAITING_FOR_RPC_REPLY | extra_state,
       the_packet->timeout,
+      WATCHDOG_RELATIVE,
       2
     );
 
@@ -328,6 +329,7 @@ void _MPCI_Receive_server(
 
   executing = _Thread_Get_executing();
   _Thread_queue_Context_initialize( &queue_context );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_NO_TIMEOUT );
 
   for ( ; ; ) {
 
@@ -339,7 +341,6 @@ void _MPCI_Receive_server(
       MPCI_SEMAPHORE_TQ_OPERATIONS,
       executing,
       true,
-      WATCHDOG_NO_TIMEOUT,
       &queue_context
     );
 
diff --git a/cpukit/score/src/mutex.c b/cpukit/score/src/mutex.c
index ed374a0768..4b5127cda1 100644
--- a/cpukit/score/src/mutex.c
+++ b/cpukit/score/src/mutex.c
@@ -104,7 +104,6 @@ static void _Mutex_Acquire_slow(
   Mutex_Control        *mutex,
   Thread_Control       *owner,
   Thread_Control       *executing,
-  Watchdog_Interval     timeout,
   Thread_queue_Context *queue_context
 )
 {
@@ -115,7 +114,6 @@ static void _Mutex_Acquire_slow(
     MUTEX_TQ_OPERATIONS,
     executing,
     STATES_WAITING_FOR_SYS_LOCK_MUTEX,
-    timeout,
     queue_context
   );
 }
@@ -219,7 +217,8 @@ void _Mutex_Acquire( struct _Mutex_Control *_mutex )
     ++executing->resource_count;
     _Mutex_Queue_release( mutex, &queue_context );
   } else {
-    _Mutex_Acquire_slow( mutex, owner, executing, 0, &queue_context );
+    _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_NO_TIMEOUT );
+    _Mutex_Acquire_slow( mutex, owner, executing, &queue_context );
   }
 }
 
@@ -260,7 +259,9 @@ int _Mutex_Acquire_timed(
         break;
     }
 
-    _Mutex_Acquire_slow( mutex, owner, executing, ticks, &queue_context );
+    _Thread_queue_Context_set_timeout( &queue_context, ticks );
+    _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_RELATIVE );
+    _Mutex_Acquire_slow( mutex, owner, executing, &queue_context );
 
     return STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) );
   }
@@ -336,7 +337,8 @@ void _Mutex_recursive_Acquire( struct _Mutex_recursive_Control *_mutex )
     ++mutex->nest_level;
     _Mutex_Queue_release( &mutex->Mutex, &queue_context );
   } else {
-    _Mutex_Acquire_slow( &mutex->Mutex, owner, executing, 0, &queue_context );
+    _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_NO_TIMEOUT );
+    _Mutex_Acquire_slow( &mutex->Mutex, owner, executing, &queue_context );
   }
 }
 
@@ -382,13 +384,9 @@ int _Mutex_recursive_Acquire_timed(
         break;
     }
 
-    _Mutex_Acquire_slow(
-      &mutex->Mutex,
-      owner,
-      executing,
-      ticks,
-      &queue_context
-    );
+    _Thread_queue_Context_set_timeout( &queue_context, ticks );
+    _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_RELATIVE );
+    _Mutex_Acquire_slow( &mutex->Mutex, owner, executing, &queue_context );
 
     return STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) );
   }
diff --git a/cpukit/score/src/semaphore.c b/cpukit/score/src/semaphore.c
index 03af9cff7e..799bd0a3a3 100644
--- a/cpukit/score/src/semaphore.c
+++ b/cpukit/score/src/semaphore.c
@@ -101,12 +101,12 @@ void _Semaphore_Wait( struct _Semaphore_Control *_sem )
     _Semaphore_Queue_release( sem, &queue_context );
   } else {
     _Thread_queue_Context_set_expected_level( &queue_context, 1 );
+    _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_NO_TIMEOUT );
     _Thread_queue_Enqueue_critical(
       &sem->Queue.Queue,
       SEMAPHORE_TQ_OPERATIONS,
       executing,
       STATES_WAITING_FOR_SYS_LOCK_SEMAPHORE,
-      WATCHDOG_NO_TIMEOUT,
       &queue_context
     );
   }
diff --git a/cpukit/score/src/threadqenqueue.c b/cpukit/score/src/threadqenqueue.c
index 8bd19058ff..ee8089ae48 100644
--- a/cpukit/score/src/threadqenqueue.c
+++ b/cpukit/score/src/threadqenqueue.c
@@ -39,12 +39,13 @@ void _Thread_queue_Enqueue_critical(
   const Thread_queue_Operations *operations,
   Thread_Control                *the_thread,
   States_Control                 state,
-  Watchdog_Interval              timeout,
   Thread_queue_Context          *queue_context
 )
 {
   Per_CPU_Control *cpu_self;
   bool             success;
+  Watchdog_Interval timeout = queue_context->timeout;
+  Watchdog_Discipline discipline = queue_context->timeout_discipline;
 
 #if defined(RTEMS_MULTIPROCESSING)
   if ( _Thread_MP_Is_receive( the_thread ) && the_thread->receive_packet ) {
@@ -83,13 +84,23 @@ void _Thread_queue_Enqueue_critical(
   /*
    *  If the thread wants to timeout, then schedule its timer.
    */
-  if ( timeout != WATCHDOG_NO_TIMEOUT ) {
-    _Thread_Timer_insert_relative(
-      the_thread,
-      cpu_self,
-      _Thread_Timeout,
-      timeout
-    );
+  switch ( discipline ) {
+    case WATCHDOG_RELATIVE:
+      if ( timeout == WATCHDOG_NO_TIMEOUT ) {
+        /* A relative timeout of 0 is an indefinite wait */
+        break;
+      } /* Fall-through */
+    case WATCHDOG_ABSOLUTE:
+      _Thread_Timer_insert(
+         the_thread,
+         cpu_self,
+         _Thread_Timeout,
+         timeout,
+         discipline
+       );
+      break;
+    default:
+      break;
   }
 
   /*
diff --git a/cpukit/score/src/threadrestart.c b/cpukit/score/src/threadrestart.c
index 21e260b10b..ad16e6a3c3 100644
--- a/cpukit/score/src/threadrestart.c
+++ b/cpukit/score/src/threadrestart.c
@@ -472,7 +472,6 @@ void _Thread_Join(
     THREAD_JOIN_TQ_OPERATIONS,
     executing,
     waiting_for_join,
-    WATCHDOG_NO_TIMEOUT,
     queue_context
   );
 }
@@ -539,6 +538,7 @@ void _Thread_Close( Thread_Control *the_thread, Thread_Control *executing )
 
   _Thread_queue_Context_initialize( &queue_context );
   _Thread_queue_Context_set_expected_level( &queue_context, 2 );
+  _Thread_queue_Context_set_discipline( &queue_context, WATCHDOG_NO_TIMEOUT );
   _Thread_State_acquire( the_thread, &queue_context.Lock_context );
   _Thread_Join(
     the_thread,