Index: cpukit/ChangeLog
===================================================================
--- cpukit/ChangeLog	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/ChangeLog	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -1,2 +1,39 @@
+2008-07-24	Joel Sherrill <joel.sherrill@OARcorp.com>
+
+	PR 1291/cpukit
+	* posix/src/posixtimespecabsolutetimeout.c: New file.
+	* itron/inline/rtems/itron/semaphore.inl, itron/src/twai_sem.c,
+	posix/Makefile.am, posix/include/mqueue.h,
+	posix/include/rtems/posix/mqueue.h,
+	posix/include/rtems/posix/semaphore.h,
+	posix/include/rtems/posix/time.h, posix/src/condtimedwait.c,
+	posix/src/mqueuereceive.c, posix/src/mqueuerecvsupp.c,
+	posix/src/mqueuesend.c, posix/src/mqueuesendsupp.c,
+	posix/src/mqueuetimedreceive.c, posix/src/mqueuetimedsend.c,
+	posix/src/mutexfromcorestatus.c, posix/src/mutextimedlock.c,
+	posix/src/semaphorewaitsupp.c, posix/src/semtimedwait.c,
+	posix/src/semtrywait.c, posix/src/semwait.c, rtems/src/semobtain.c,
+	rtems/src/semtranslatereturncode.c,
+	score/include/rtems/score/coresem.h, score/src/coremsgseize.c,
+	score/src/coresemseize.c:
+	This patch addresses issues on implementation of the timeout on the
+	following POSIX services. Some of these services incorrectly took a
+	timeout as a relative time. Others would compute a 0 delta to timeout
+	if the absolute time and the current time were equal and thus
+	incorrectly block the caller forever. The root of the confusion is
+	that POSIX specifies that if the timeout is incorrect (e.g. in the
+	past, is now, or is numerically invalid), that it does not matter if
+	the call would succeed without blocking. This is in contrast to RTEMS
+	programming style where all errors are checked before any critical
+	sections are entered. This fix implemented a more uniform way of
+	handling POSIX absolute time timeouts.
+	    + pthread_cond_timedwait - could block forever
+	    + mq_timedreceive - used relative not absolute time
+	    + mq_timedsend - used relative not absolute time
+	    + pthread_mutex_timedlock - used relative not absolute time
+	    + pthread_rwlock_timedrdlock- used relative not absolute time
+	    + pthread_rwlock_timedwrlock- used relative not absolute time
+	    + sem_timedwait - could block forever
+
 2008-04-25	Joel Sherrill <joel.sherrill@OARcorp.com>
 
Index: cpukit/itron/inline/rtems/itron/semaphore.inl
===================================================================
--- cpukit/itron/inline/rtems/itron/semaphore.inl	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/itron/inline/rtems/itron/semaphore.inl	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -173,6 +173,4 @@
     case CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED:
       return E_QOVR;
-    case CORE_SEMAPHORE_BAD_TIMEOUT_VALUE:
-      return E_PAR;
     case THREAD_STATUS_PROXY_BLOCKING:
       return THREAD_STATUS_PROXY_BLOCKING;
Index: cpukit/itron/src/twai_sem.c
===================================================================
--- cpukit/itron/src/twai_sem.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/itron/src/twai_sem.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -31,14 +31,14 @@
 )
 {
-  ITRON_Semaphore_Control        *the_semaphore;
-  Objects_Locations               location;
-  Watchdog_Interval               interval;
-  Core_semaphore_Blocking_option  blocking;
+  ITRON_Semaphore_Control  *the_semaphore;
+  Objects_Locations         location;
+  Watchdog_Interval         interval;
+  boolean                   blocking;
 
   interval = 0;
   if ( tmout == TMO_POL ) {
-    blocking = CORE_SEMAPHORE_NO_WAIT;
+    blocking = FALSE;
   } else {
-    blocking = CORE_SEMAPHORE_BLOCK_FOREVER;
+    blocking = TRUE;
 
     if ( tmout != TMO_FEVR )
Index: cpukit/posix/Makefile.am
===================================================================
--- cpukit/posix/Makefile.am	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/Makefile.am	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -133,8 +133,9 @@
 ## TIME_C_FILES
 libposix_a_SOURCES += src/adjtime.c src/time.c src/posixtimespecsubtract.c \
-    src/posixtimespectointerval.c src/posixintervaltotimespec.c \
-    src/clockgetcpuclockid.c src/clockgetenableattr.c src/clockgetres.c \
-    src/clockgettime.c src/clocksetenableattr.c src/clocksettime.c \
-    src/nanosleep.c src/sleep.c src/usleep.c
+    src/posixtimespecabsolutetimeout.c src/posixtimespectointerval.c \
+    src/posixintervaltotimespec.c src/clockgetcpuclockid.c \
+    src/clockgetenableattr.c src/clockgetres.c src/clockgettime.c \
+    src/clocksetenableattr.c src/clocksettime.c src/nanosleep.c src/sleep.c \
+    src/usleep.c
 
 # the timer manager needs to be split further but only after its
Index: cpukit/posix/include/mqueue.h
===================================================================
--- cpukit/posix/include/mqueue.h	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/include/mqueue.h	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -27,17 +27,26 @@
  */
 
+/**
+ *  Message queue id type
+ */
 typedef Objects_Id  mqd_t;
 
+/**
+ *  This is the message queue attributes structure.
+ */
 struct mq_attr {
-  long  mq_flags;     /* Message queue flags */
-  long  mq_maxmsg;    /* Maximum number of messages */
-  long  mq_msgsize;   /* Maximum message size */
-  long  mq_curmsgs;   /* Number of messages currently queued */
+  /** This is the message queue flags */
+  long  mq_flags;
+  /** This is the maximum number of messages */
+  long  mq_maxmsg;
+  /** This is the maximum message size */
+  long  mq_msgsize;
+  /** This is the mumber of messages currently queued */
+  long  mq_curmsgs;
 };
 
-/*
+/**
  *  15.2.2 Open a Message Queue, P1003.1b-1993, p. 272
  */
-
 mqd_t mq_open(
   const char *name,
@@ -46,26 +55,23 @@
 );
 
-/*
+/**
  *  15.2.2 Close a Message Queue, P1003.1b-1993, p. 275
  */
-
 int mq_close(
   mqd_t  mqdes
 );
 
-/*
+/**
  *  15.2.2 Remove a Message Queue, P1003.1b-1993, p. 276
  */
-
 int mq_unlink(
   const char *name
 );
 
-/*
+/**
  *  15.2.4 Send a Message to a Message Queue, P1003.1b-1993, p. 277
  *
- *  NOTE: P1003.4b/D8, p. 45 adds mq_timedsend().
+ *  @note P1003.4b/D8, p. 45 adds mq_timedsend().
  */
-
 int mq_send(
   mqd_t         mqdes,
@@ -84,5 +90,5 @@
   size_t                 msg_len,
   unsigned int           msg_prio,
-  const struct timespec *timeout
+  const struct timespec *abstime
 );
 
@@ -109,5 +115,5 @@
   size_t                 msg_len,
   unsigned int          *msg_prio,
-  const struct timespec *timeout
+  const struct timespec *abstime
 );
 
Index: cpukit/posix/include/rtems/posix/mqueue.h
===================================================================
--- cpukit/posix/include/rtems/posix/mqueue.h	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/include/rtems/posix/mqueue.h	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -113,4 +113,5 @@
   size_t              msg_len,
   unsigned int       *msg_prio,
+  boolean             wait,
   Watchdog_Interval   timeout
 );
@@ -129,4 +130,5 @@
   size_t              msg_len,
   uint32_t            msg_prio,
+  boolean             wait,
   Watchdog_Interval   timeout
 );
Index: cpukit/posix/include/rtems/posix/semaphore.h
===================================================================
--- cpukit/posix/include/rtems/posix/semaphore.h	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/include/rtems/posix/semaphore.h	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -154,7 +154,7 @@
 
 int _POSIX_Semaphore_Wait_support(
-  sem_t                          *sem,
-  Core_semaphore_Blocking_option  blocking,
-  Watchdog_Interval               timeout
+  sem_t               *sem,
+  boolean              blocking,
+  Watchdog_Interval    timeout
 );
 
Index: cpukit/posix/include/rtems/posix/time.h
===================================================================
--- cpukit/posix/include/rtems/posix/time.h	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/include/rtems/posix/time.h	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -13,4 +13,21 @@
 
 #include <rtems/score/tod.h>
+
+/*  Absolute Timeout Conversion Results
+ *
+ *  This enumeration defines the possible results of converting
+ *  an absolute time used for timeouts to POSIX blocking calls to
+ *  a number of ticks.
+ */
+typedef enum {
+  /* The timeout is invalid. */
+  POSIX_ABSOLUTE_TIMEOUT_INVALID,
+  /* The timeout represents a time that is in the past. */
+  POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST,
+  /* The timeout represents a time that is equal to the current time. */
+  POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
+  /* The timeout represents a time that is in the future. */
+  POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE,
+} POSIX_Absolute_timeout_conversion_results_t;
 
 /*
@@ -52,3 +69,23 @@
 );
 
+/*
+ *  Convert Absolute Timeout to Ticks
+ *
+ *  This method takes an absolute time being used as a timeout
+ *  to a blocking directive, validates it and returns the number
+ *  of corresponding clock ticks for use by the SuperCore.
+ *
+ *  abstime   - is the timeout
+ *  ticks_out -  will contain the number of ticks
+ *
+ *  This method returns the number of ticks in @a ticks_out
+ *  and a status value indicating whether the absolute time
+ *  is valid, in the past, equal to the current time or in 
+ *  the future as it should be.
+ */
+POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks(
+  const struct timespec *abstime,
+  Watchdog_Interval     *ticks_out
+);
+
 #endif
Index: cpukit/posix/src/condtimedwait.c
===================================================================
--- cpukit/posix/src/condtimedwait.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/src/condtimedwait.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -29,32 +29,32 @@
 )
 {
-  Watchdog_Interval timeout;
-  struct timespec   current_time;
-  struct timespec   difference;
-  boolean           already_timedout = FALSE;
-
-  if ( !abstime )
-    return EINVAL;
+  Watchdog_Interval ticks;
+  boolean           already_timedout;
 
   /*
-   *  The abstime is a walltime.  We turn it into an interval.
+   *  POSIX requires that blocking calls with timeouts that take
+   *  an absolute timeout must ignore issues with the absolute
+   *  time provided if the operation would otherwise succeed.
+   *  So we check the abstime provided, and hold on to whether it
+   *  is valid or not.  If it isn't correct and in the future,
+   *  then we do a polling operation and convert the UNSATISFIED
+   *  status into the appropriate error.
    */
-
-  (void) clock_gettime( CLOCK_REALTIME, &current_time );
-
-  /* XXX probably some error checking should go here */
-
-  _POSIX_Timespec_subtract( &current_time, abstime, &difference );
-
-  if ( ( difference.tv_sec < 0 ) || ( ( difference.tv_sec == 0 ) &&
-       ( difference.tv_nsec < 0 ) ) )
-    already_timedout = TRUE;
-
-  timeout = _POSIX_Timespec_to_interval( &difference );
+  switch ( _POSIX_Absolute_timeout_to_ticks(abstime, &ticks) ) {
+    case POSIX_ABSOLUTE_TIMEOUT_INVALID:
+      return EINVAL;
+    case POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST:
+    case POSIX_ABSOLUTE_TIMEOUT_IS_NOW:
+      already_timedout = TRUE;
+      break;
+    case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:
+      already_timedout = FALSE;
+      break;
+  }
 
   return _POSIX_Condition_variables_Wait_support(
     cond,
     mutex,
-    timeout,
+    ticks,
     already_timedout
   );
Index: cpukit/posix/src/mqueuereceive.c
===================================================================
--- cpukit/posix/src/mqueuereceive.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/src/mqueuereceive.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -52,4 +52,5 @@
     msg_len,
     msg_prio,
+    TRUE,
     THREAD_QUEUE_WAIT_FOREVER
   );
Index: cpukit/posix/src/mqueuerecvsupp.c
===================================================================
--- cpukit/posix/src/mqueuerecvsupp.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/src/mqueuerecvsupp.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -33,6 +33,5 @@
 #include <rtems/posix/time.h>
 
-/*PAGE
- *
+/*
  *  _POSIX_Message_queue_Receive_support
  *
@@ -46,4 +45,5 @@
   size_t              msg_len,
   unsigned int       *msg_prio,
+  boolean             wait,
   Watchdog_Interval   timeout
 )
@@ -53,4 +53,5 @@
   Objects_Locations                location;
   size_t                           length_out;
+  boolean                          do_wait;
 
   the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
@@ -82,4 +83,15 @@
       length_out = -1;
 
+      /*
+       *  A timed receive with a bad time will do a poll regardless.
+       */
+      if ( wait )
+        do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE;
+      else
+        do_wait = wait;
+
+      /*
+       *  Now perform the actual message receive
+       */
       _CORE_message_queue_Seize(
         &the_mq->Message_queue,
@@ -87,5 +99,5 @@
         msg_ptr,
         &length_out,
-        (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE,
+        do_wait,
         timeout
       );
Index: cpukit/posix/src/mqueuesend.c
===================================================================
--- cpukit/posix/src/mqueuesend.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/src/mqueuesend.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -52,4 +52,5 @@
     msg_len,
     msg_prio,
+    TRUE,
     THREAD_QUEUE_WAIT_FOREVER
   );
Index: cpukit/posix/src/mqueuesendsupp.c
===================================================================
--- cpukit/posix/src/mqueuesendsupp.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/src/mqueuesendsupp.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -44,4 +44,5 @@
   size_t              msg_len,
   uint32_t            msg_prio,
+  boolean             wait,
   Watchdog_Interval   timeout
 )
@@ -51,4 +52,5 @@
   Objects_Locations               location;
   CORE_message_queue_Status       msg_status;
+  boolean                         do_wait;
 
   /*
@@ -78,4 +80,15 @@
       the_mq = the_mq_fd->Queue;
 
+      /*
+       *  A timed receive with a bad time will do a poll regardless.
+       */
+      if ( wait )
+        do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE;
+      else
+        do_wait = wait;
+
+      /*
+       *  Now perform the actual message receive
+       */
       msg_status = _CORE_message_queue_Submit(
         &the_mq->Message_queue,
@@ -89,5 +102,5 @@
 #endif
         _POSIX_Message_queue_Priority_to_core( msg_prio ),
-         (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE,
+        do_wait,
         timeout    /* no timeout */
       );
Index: cpukit/posix/src/mqueuetimedreceive.c
===================================================================
--- cpukit/posix/src/mqueuetimedreceive.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/src/mqueuetimedreceive.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -45,7 +45,30 @@
   size_t                 msg_len,
   unsigned int          *msg_prio,
-  const struct timespec *timeout
+  const struct timespec *abstime
 )
 {
+  Watchdog_Interval ticks;
+  boolean           do_wait;
+
+  /*
+   *  POSIX requires that blocking calls with timeouts that take
+   *  an absolute timeout must ignore issues with the absolute
+   *  time provided if the operation would otherwise succeed.
+   *  So we check the abstime provided, and hold on to whether it
+   *  is valid or not.  If it isn't correct and in the future,
+   *  then we do a polling operation and convert the UNSATISFIED
+   *  status into the appropriate error.
+   */
+  switch ( _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ) ) {
+    case POSIX_ABSOLUTE_TIMEOUT_INVALID:
+    case POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST:
+    case POSIX_ABSOLUTE_TIMEOUT_IS_NOW:
+      do_wait = FALSE;
+      break;
+    case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:
+      do_wait = TRUE;
+      break;
+  }
+
   return _POSIX_Message_queue_Receive_support(
     mqdes,
@@ -53,5 +76,6 @@
     msg_len,
     msg_prio,
-    _POSIX_Timespec_to_interval( timeout )
+    do_wait,
+    ticks
   );
 }
Index: cpukit/posix/src/mqueuetimedsend.c
===================================================================
--- cpukit/posix/src/mqueuetimedsend.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/src/mqueuetimedsend.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -45,7 +45,30 @@
   size_t                 msg_len,
   unsigned int           msg_prio,
-  const struct timespec *timeout
+  const struct timespec *abstime
 )
 {
+  Watchdog_Interval ticks;
+  boolean           do_wait;
+
+  /*
+   *  POSIX requires that blocking calls with timeouts that take
+   *  an absolute timeout must ignore issues with the absolute
+   *  time provided if the operation would otherwise succeed.
+   *  So we check the abstime provided, and hold on to whether it
+   *  is valid or not.  If it isn't correct and in the future,
+   *  then we do a polling operation and convert the UNSATISFIED
+   *  status into the appropriate error.
+   */
+  switch ( _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ) ) {
+    case POSIX_ABSOLUTE_TIMEOUT_INVALID:
+    case POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST:
+    case POSIX_ABSOLUTE_TIMEOUT_IS_NOW:
+      do_wait = FALSE;
+      break;
+    case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:
+      do_wait = TRUE;
+      break;
+  }
+
   return _POSIX_Message_queue_Send_support(
     mqdes,
@@ -53,5 +76,6 @@
     msg_len,
     msg_prio,
-    _POSIX_Timespec_to_interval( timeout )
+    do_wait,
+    ticks
   );
 }
Index: cpukit/posix/src/mutexfromcorestatus.c
===================================================================
--- cpukit/posix/src/mutexfromcorestatus.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/src/mutexfromcorestatus.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -42,5 +42,5 @@
       return EINVAL;
     case CORE_MUTEX_TIMEOUT:
-      return EAGAIN;
+      return ETIMEDOUT;
     case CORE_MUTEX_STATUS_CEILING_VIOLATED:
       return EINVAL;
Index: cpukit/posix/src/mutextimedlock.c
===================================================================
--- cpukit/posix/src/mutextimedlock.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/src/mutextimedlock.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -29,11 +29,57 @@
 int pthread_mutex_timedlock(
   pthread_mutex_t       *mutex,
-  const struct timespec *timeout
+  const struct timespec *abstime
 )
 {
-  return _POSIX_Mutex_Lock_support(
+  Watchdog_Interval                            ticks;
+  boolean                                      do_wait;
+  POSIX_Absolute_timeout_conversion_results_t  status;
+  int                                          lock_status;
+
+  /*
+   *  POSIX requires that blocking calls with timeouts that take
+   *  an absolute timeout must ignore issues with the absolute
+   *  time provided if the operation would otherwise succeed.
+   *  So we check the abstime provided, and hold on to whether it
+   *  is valid or not.  If it isn't correct and in the future,
+   *  then we do a polling operation and convert the UNSATISFIED
+   *  status into the appropriate error.
+   */
+  status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
+  switch ( status ) {
+    case POSIX_ABSOLUTE_TIMEOUT_INVALID:
+    case POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST:
+    case POSIX_ABSOLUTE_TIMEOUT_IS_NOW:
+      do_wait = FALSE;
+      break;
+    case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:
+      do_wait = TRUE;
+      break;
+  }
+
+  lock_status = _POSIX_Mutex_Lock_support(
     mutex,
-    TRUE,
-    _POSIX_Timespec_to_interval( timeout )
+    do_wait,
+    ticks
   );
+
+  /*
+   *  This service only gives us the option to block.  We used a polling
+   *  attempt to lock if the abstime was not in the future.  If we did
+   *  not obtain the mutex, then not look at the status immediately,
+   *  make sure the right reason is returned.
+   */
+  if ( !do_wait && (lock_status == EBUSY) ) {
+    switch (lock_status) {
+      case POSIX_ABSOLUTE_TIMEOUT_INVALID:
+        return EINVAL;
+      case POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST:
+      case POSIX_ABSOLUTE_TIMEOUT_IS_NOW:
+        return ETIMEDOUT;
+      case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:
+        break;
+    }
+  }
+
+  return lock_status;
 }
Index: cpukit/posix/src/posixtimespecabsolutetimeout.c
===================================================================
--- cpukit/posix/src/posixtimespecabsolutetimeout.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
+++ cpukit/posix/src/posixtimespecabsolutetimeout.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -0,0 +1,126 @@
+/*
+ *  Convert abstime timeout to ticks
+ */
+
+/*
+ *  COPYRIGHT (c) 1989-2007.
+ *  On-Line Applications Research Corporation (OAR).
+ *
+ *  The license and distribution terms for this file may be
+ *  found in the file LICENSE in this distribution or at
+ *  http://www.rtems.com/license/LICENSE.
+ *
+ *  $Id$
+ */
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdarg.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <limits.h>
+
+#include <rtems/system.h>
+#include <rtems/score/object.h>
+#include <rtems/posix/semaphore.h>
+#include <rtems/posix/time.h>
+#include <rtems/seterr.h>
+
+static boolean _Timespec_Is_valid(
+  const struct timespec *time
+)
+{
+  if ( !time )
+    return FALSE;
+
+  if ( time->tv_sec < 0 )
+    return FALSE;
+
+  if ( time->tv_nsec < 0 )
+    return FALSE;
+
+  if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
+    return FALSE;
+
+  return TRUE;
+}
+
+static boolean _Timespec_Less_than(
+  const struct timespec *lhs,
+  const struct timespec *rhs
+)
+{
+  if ( lhs->tv_sec < rhs->tv_sec )
+    return TRUE;
+
+  if ( lhs->tv_sec > rhs->tv_sec )
+    return FALSE;
+
+  /* ASSERT: lhs->tv_sec == rhs->tv_sec */
+  if ( lhs->tv_nsec < rhs->tv_nsec )
+    return TRUE;
+
+  return FALSE;
+}
+
+
+/*
+ *  The abstime is a walltime.  We turn it into an interval.
+ */
+POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks(
+  const struct timespec *abstime,
+  Watchdog_Interval     *ticks_out
+)
+{
+  struct timespec current_time;
+  struct timespec difference;
+
+  
+  /*
+   *  Make sure there is always a value returned.
+   */
+  *ticks_out = 0;
+
+  /*
+   *  Is the absolute time even valid?
+   */
+  if ( !_Timespec_Is_valid(abstime) )
+    return POSIX_ABSOLUTE_TIMEOUT_INVALID;
+
+  /*
+   *  Is the absolute time in the past?
+   */
+  clock_gettime( CLOCK_REALTIME, &current_time );
+
+  if ( _Timespec_Less_than( abstime, &current_time ) )
+    return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
+
+  /*
+   *  How long until the requested absolute time?
+   */
+  _POSIX_Timespec_subtract( &current_time, abstime, &difference );
+
+  /*
+   *  Internally the SuperCore uses ticks, so convert to them.
+   */
+  *ticks_out = _POSIX_Timespec_to_interval( &difference );
+
+  /*
+   *  If the difference was 0, then the future is now.  It is so bright
+   *  we better wear shades.
+   */
+  if ( !*ticks_out )
+    return POSIX_ABSOLUTE_TIMEOUT_IS_NOW;
+
+  /*
+   *  This is the case we were expecting and it took this long to
+   *  get here.
+   */
+  return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE;
+}
+
Index: cpukit/posix/src/semaphorewaitsupp.c
===================================================================
--- cpukit/posix/src/semaphorewaitsupp.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/src/semaphorewaitsupp.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -27,7 +27,7 @@
 
 int _POSIX_Semaphore_Wait_support(
-  sem_t                          *sem,
-  Core_semaphore_Blocking_option  blocking,
-  Watchdog_Interval               timeout
+  sem_t             *sem,
+  boolean            blocking,
+  Watchdog_Interval  timeout
 )
 {
@@ -66,7 +66,4 @@
            */
  	  break;
-	case CORE_SEMAPHORE_BAD_TIMEOUT_VALUE:
-          rtems_set_errno_and_return_minus_one( EINVAL );
-	  break;
       }
   }
Index: cpukit/posix/src/semtimedwait.c
===================================================================
--- cpukit/posix/src/semtimedwait.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/src/semtimedwait.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -33,39 +33,50 @@
 )
 {
-  /*
-   *  The abstime is a walltime.  We turn it into an interval.
-   */
-  Watchdog_Interval              ticks = 0;
-  struct timespec                current_time;
-  struct timespec                difference;
-  Core_semaphore_Blocking_option blocking = CORE_SEMAPHORE_BLOCK_WITH_TIMEOUT;
+  Watchdog_Interval                            ticks;
+  boolean                                      do_wait = TRUE;
+  POSIX_Absolute_timeout_conversion_results_t  status;
+  int                                          lock_status;
 
   /*
-   *  Error check the absolute time to timeout
+   *  POSIX requires that blocking calls with timeouts that take
+   *  an absolute timeout must ignore issues with the absolute
+   *  time provided if the operation would otherwise succeed.
+   *  So we check the abstime provided, and hold on to whether it
+   *  is valid or not.  If it isn't correct and in the future,
+   *  then we do a polling operation and convert the UNSATISFIED
+   *  status into the appropriate error.
    */
-#if 0
-  if ( /* abstime->tv_sec < 0 || */ abstime->tv_nsec ) /* tv_sec is unsigned */
-    blocking = CORE_SEMAPHORE_BAD_TIMEOUT_VALUE;
-  else
-#endif
-  if ( abstime->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
-    blocking = CORE_SEMAPHORE_BAD_TIMEOUT;
-  } else { 
-    clock_gettime( CLOCK_REALTIME, &current_time );
-    /*
-     *  Make sure the abstime is in the future
-     */
-    if ( abstime->tv_sec < current_time.tv_sec )
-      blocking = CORE_SEMAPHORE_BAD_TIMEOUT;
-    else if ( (abstime->tv_sec == current_time.tv_sec) &&
-         (abstime->tv_nsec <= current_time.tv_nsec) )
-      blocking = CORE_SEMAPHORE_BAD_TIMEOUT;
-    else {
-      _POSIX_Timespec_subtract( &current_time, abstime, &difference );
-      ticks = _POSIX_Timespec_to_interval( &difference );
-      blocking = CORE_SEMAPHORE_BLOCK_WITH_TIMEOUT;
+  status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
+  switch ( status ) {
+    case POSIX_ABSOLUTE_TIMEOUT_INVALID:
+    case POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST:
+    case POSIX_ABSOLUTE_TIMEOUT_IS_NOW:
+      do_wait = FALSE;
+      break;
+    case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:
+      do_wait = TRUE;
+      break;
+  }
+
+  lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
+
+  /*
+   *  This service only gives us the option to block.  We used a polling
+   *  attempt to obtain if the abstime was not in the future.  If we did
+   *  not obtain the semaphore, then not look at the status immediately,
+   *  make sure the right reason is returned.
+   */
+  if ( !do_wait && (lock_status == EBUSY) ) {
+    switch (lock_status) {
+      case POSIX_ABSOLUTE_TIMEOUT_INVALID:
+        return EINVAL;
+      case POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST:
+      case POSIX_ABSOLUTE_TIMEOUT_IS_NOW:
+        return ETIMEDOUT;
+      case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:
+        break;
     }
-   }
+  }
 
-   return _POSIX_Semaphore_Wait_support( sem, blocking, ticks );
+  return lock_status;
 }
Index: cpukit/posix/src/semtrywait.c
===================================================================
--- cpukit/posix/src/semtrywait.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/src/semtrywait.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -32,4 +32,4 @@
 )
 {
-  return _POSIX_Semaphore_Wait_support( sem, FALSE, THREAD_QUEUE_WAIT_FOREVER );
+  return _POSIX_Semaphore_Wait_support(sem, FALSE, THREAD_QUEUE_WAIT_FOREVER);
 }
Index: cpukit/posix/src/semwait.c
===================================================================
--- cpukit/posix/src/semwait.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/posix/src/semwait.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -32,8 +32,4 @@
 )
 {
-  return _POSIX_Semaphore_Wait_support(
-           sem,
-           CORE_SEMAPHORE_BLOCK_FOREVER,
-           THREAD_QUEUE_WAIT_FOREVER
-         );
+  return _POSIX_Semaphore_Wait_support( sem, TRUE, THREAD_QUEUE_WAIT_FOREVER );
 }
Index: cpukit/rtems/src/semobtain.c
===================================================================
--- cpukit/rtems/src/semobtain.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/rtems/src/semobtain.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -108,6 +108,5 @@
         &the_semaphore->Core_control.semaphore,
         id,
-        ((_Options_Is_no_wait( option_set )) ?
-          CORE_SEMAPHORE_NO_WAIT : CORE_SEMAPHORE_BLOCK_FOREVER),
+        ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE),
         timeout,
         &level
Index: cpukit/rtems/src/semtranslatereturncode.c
===================================================================
--- cpukit/rtems/src/semtranslatereturncode.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/rtems/src/semtranslatereturncode.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -104,5 +104,4 @@
   RTEMS_TIMEOUT,            /* CORE_SEMAPHORE_TIMEOUT  */
   RTEMS_INTERNAL_ERROR,     /* CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED */
-  RTEMS_INTERNAL_ERROR      /* CORE_SEMAPHORE_BAD_TIMEOUT_VALUE */
 };
 
@@ -115,5 +114,5 @@
     return RTEMS_PROXY_BLOCKING;
 #endif
-  if ( status > CORE_MUTEX_STATUS_CEILING_VIOLATED )
+  if ( status > CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED )
     return RTEMS_INTERNAL_ERROR;
   return _Semaphore_Translate_core_semaphore_return_code_[status];
Index: cpukit/score/include/rtems/score/coresem.h
===================================================================
--- cpukit/score/include/rtems/score/coresem.h	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/score/include/rtems/score/coresem.h	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -83,12 +83,5 @@
    *  and this would have made its count greater than that allowed.
    */
-  CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED,
-  /** This status indicates that the semaphore was not immediately
-   *  available and the caller passed a bad timeout value to the API
-   *  routine.  In this case, the API required that the validity check
-   *  for the timeout occur after the check that the semaphore was immediately
-   *  available.
-   */
-  CORE_SEMAPHORE_BAD_TIMEOUT_VALUE
+  CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED
 }   CORE_semaphore_Status;
 
@@ -124,23 +117,4 @@
 
 /**
- *  The following enumerated type is the set of blocking options
- *  available to seize operation.
- */
-typedef enum {
-  /** This value indicates that the caller does not wish to block. */
-  CORE_SEMAPHORE_NO_WAIT,
-  /** This value indicates that the caller is willing to block forever. */
-  CORE_SEMAPHORE_BLOCK_FOREVER,
-  /** This value indicates that the caller is blocking with a timeout. */
-  CORE_SEMAPHORE_BLOCK_WITH_TIMEOUT,
-  /** This value indicates that the caller wanted to block but passed in
-   *  a bad timeout value to the API. Unfortunately, this is a weird case
-   *  where the timeout bad error is required to be generated only if
-   *  the semaphore is not available.
-   */
-  CORE_SEMAPHORE_BAD_TIMEOUT
-} Core_semaphore_Blocking_option;
-
-/**
  *  This routine initializes the semaphore based on the parameters passed.
  *
@@ -164,13 +138,13 @@
  *  @param[in] id is the Id of the API level Semaphore object associated
  *         with this instance of a SuperCore Semaphore
- *  @param[in] wait is the blocking mode
+ *  @param[in] wait indicates if the caller is willing to block
  *  @param[in] timeout is the number of ticks the calling thread is willing
  *         to wait if @a wait is TRUE.
  */
 void _CORE_semaphore_Seize(
-  CORE_semaphore_Control         *the_semaphore,
-  Objects_Id                      id,
-  Core_semaphore_Blocking_option  wait,
-  Watchdog_Interval               timeout
+  CORE_semaphore_Control  *the_semaphore,
+  Objects_Id               id,
+  boolean                  wait,
+  Watchdog_Interval        timeout
 );
 
Index: cpukit/score/src/coremsgseize.c
===================================================================
--- cpukit/score/src/coremsgseize.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/score/src/coremsgseize.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -85,5 +85,5 @@
     *size = the_message->Contents.size;
     _Thread_Executing->Wait.count = the_message->priority;
-    _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size);
+    _CORE_message_queue_Copy_buffer(the_message->Contents.buffer, buffer,*size);
 
     /*
@@ -108,5 +108,5 @@
 
     the_message->priority  = the_thread->Wait.count;
-    the_message->Contents.size = (uint32_t  )the_thread->Wait.return_argument_1;
+    the_message->Contents.size = (uint32_t)the_thread->Wait.option;
     _CORE_message_queue_Copy_buffer(
       the_thread->Wait.return_argument,
Index: cpukit/score/src/coresemseize.c
===================================================================
--- cpukit/score/src/coresemseize.c	(revision 5e60f15d2304ff4a16ca9c27b744919390befe6f)
+++ cpukit/score/src/coresemseize.c	(revision d17c1140a84559e1fbfb082def45fbdcb487e85f)
@@ -52,8 +52,8 @@
 
 void _CORE_semaphore_Seize(
-  CORE_semaphore_Control         *the_semaphore,
-  Objects_Id                      id,
-  Core_semaphore_Blocking_option  wait,
-  Watchdog_Interval               timeout
+  CORE_semaphore_Control *the_semaphore,
+  Objects_Id              id,
+  boolean                 wait,
+  Watchdog_Interval       timeout
 )
 {
@@ -70,22 +70,19 @@
   }
 
-  switch ( wait ) {
-    case CORE_SEMAPHORE_NO_WAIT:
-      _ISR_Enable( level );
-      executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
-      return;
-    case CORE_SEMAPHORE_BAD_TIMEOUT:
-      _ISR_Enable( level );
-      executing->Wait.return_code = CORE_SEMAPHORE_BAD_TIMEOUT_VALUE;
-      return;
-    case CORE_SEMAPHORE_BLOCK_FOREVER:
-    case CORE_SEMAPHORE_BLOCK_WITH_TIMEOUT:
-      _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
-      executing->Wait.queue          = &the_semaphore->Wait_queue;
-      executing->Wait.id             = id;
-      _ISR_Enable( level );
-      _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
-      break;
+  if ( !wait ) {
+    _ISR_Enable( level );
+    executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
+    return;
   }
 
+   /*
+    *  If the semaphore is not available and the caller is willing to
+    *  block, then we now block the caller with optional timeout.
+    */
+  _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
+  executing->Wait.queue = &the_semaphore->Wait_queue;
+  executing->Wait.id    = id;
+  _ISR_Enable( level );
+  _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
+
 }
