RTOS/rtems
1
0
Fork 0
forked from Imagelibrary/rtems
Code Pull Requests Activity

2008-07-18 Joel Sherrill <joel.sherrill@oarcorp.com>

Browse Source 
PR 1291/cpukit
	* itron/inline/rtems/itron/semaphore.inl, itron/src/twai_sem.c,
	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/mutextimedlock.c, posix/src/mutextranslatereturncode.c,
	posix/src/posixtimespecabsolutetimeout.c,
	posix/src/prwlocktimedrdlock.c, posix/src/prwlocktimedwrlock.c,
	posix/src/semaphoretranslatereturncode.c,
	posix/src/semaphorewaitsupp.c, posix/src/semtimedwait.c,
	posix/src/semtrywait.c, posix/src/semwait.c,
	posix/src/sigtimedwait.c, posix/src/timersettime.c,
	posix/src/ualarm.c, rtems/src/semobtain.c,
	rtems/src/semtranslatereturncode.c,
	score/include/rtems/score/coremutex.h,
	score/include/rtems/score/coresem.h, 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
This commit is contained in:
Joel Sherrill
2008-07-22 17:17:12 +00:00
parent a570a14004
commit a2cf229615
28 changed files with 450 additions and 184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
cpukit/ChangeLog
View File

@@ -1,3 +1,43 @@
2008-07-18 Joel Sherrill <joel.sherrill@oarcorp.com>
PR 1291/cpukit
* itron/inline/rtems/itron/semaphore.inl, itron/src/twai_sem.c,
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/mutextimedlock.c, posix/src/mutextranslatereturncode.c,
posix/src/posixtimespecabsolutetimeout.c,
posix/src/prwlocktimedrdlock.c, posix/src/prwlocktimedwrlock.c,
posix/src/semaphoretranslatereturncode.c,
posix/src/semaphorewaitsupp.c, posix/src/semtimedwait.c,
posix/src/semtrywait.c, posix/src/semwait.c,
posix/src/sigtimedwait.c, posix/src/timersettime.c,
posix/src/ualarm.c, rtems/src/semobtain.c,
rtems/src/semtranslatereturncode.c,
score/include/rtems/score/coremutex.h,
score/include/rtems/score/coresem.h, 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-05-06 Joel Sherrill <joel.sherrill@OARcorp.com>
PR 1285/rtems

2
cpukit/itron/inline/rtems/itron/semaphore.inl
View File

@@ -172,8 +172,6 @@ RTEMS_INLINE_ROUTINE ER _ITRON_Semaphore_Translate_core_semaphore_return_code (
return E_TMOUT;
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;
}

6
cpukit/itron/src/twai_sem.c
View File

@@ -33,13 +33,13 @@ ER twai_sem(
ITRON_Semaphore_Control *the_semaphore;
Objects_Locations location;
Watchdog_Interval interval;
Core_semaphore_Blocking_option blocking;
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 )
interval = TOD_MILLISECONDS_TO_TICKS(tmout);

36
cpukit/posix/include/mqueue.h
View File

@@ -26,47 +26,53 @@ extern "C" {
* 15.1.1 Data Structures, P1003.1b-1993, p. 271
*/
/**
* 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,
int oflag,
...
);
/*
/**
* 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,
const char *msg_ptr,
@@ -83,7 +89,7 @@ int mq_timedsend(
const char *msg_ptr,
size_t msg_len,
unsigned int msg_prio,
const struct timespec *timeout
const struct timespec *abstime
);
#endif /* _POSIX_TIMEOUTS */
@@ -108,7 +114,7 @@ ssize_t mq_timedreceive(
char *msg_ptr,
size_t msg_len,
unsigned int *msg_prio,
const struct timespec *timeout
const struct timespec *abstime
);
#endif /* _POSIX_TIMEOUTS */

2
cpukit/posix/include/rtems/posix/mqueue.h
View File

@@ -112,6 +112,7 @@ ssize_t _POSIX_Message_queue_Receive_support(
char *msg_ptr,
size_t msg_len,
unsigned int *msg_prio,
boolean wait,
Watchdog_Interval timeout
);
@@ -128,6 +129,7 @@ int _POSIX_Message_queue_Send_support(
const char *msg_ptr,
size_t msg_len,
uint32_t msg_prio,
boolean wait,
Watchdog_Interval timeout
);

2
cpukit/posix/include/rtems/posix/semaphore.h
View File

@@ -154,7 +154,7 @@ void _POSIX_Semaphore_Delete(
int _POSIX_Semaphore_Wait_support(
sem_t *sem,
Core_semaphore_Blocking_option blocking,
boolean blocking,
Watchdog_Interval timeout
);

35
cpukit/posix/include/rtems/posix/time.h
View File

@@ -18,10 +18,39 @@
#include <rtems/score/timespec.h>
/*
* _POSIX_Absolute_timeout_to_ticks
/** @brief 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.
*/
int _POSIX_Absolute_timeout_to_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;
/**
* @brief 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.
*
* @param[in] abstime is the timeout
* @param[in] ticks_out will contain the number of ticks
*
* @return 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
);

43
cpukit/posix/src/condtimedwait.c
View File

@@ -39,37 +39,34 @@ int pthread_cond_timedwait(
const struct timespec *abstime
)
{
Watchdog_Interval timeout;
struct timespec current_time;
struct timespec difference;
boolean already_timedout = FALSE;
Watchdog_Interval ticks;
boolean already_timedout = TRUE;
if ( !_Timespec_Is_valid(abstime) )
/*
* 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:
return EINVAL;
/*
* The abstime is a walltime. We turn it into an interval.
*/
_TOD_Get( &current_time );
/*
* Make sure the timeout is in the future
*/
if ( _Timespec_Less_than( abstime, &current_time ) ) {
case POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST:
case POSIX_ABSOLUTE_TIMEOUT_IS_NOW:
already_timedout = TRUE;
difference.tv_sec = 0;
difference.tv_nsec = 0;
timeout = 0;
} else {
_Timespec_Subtract( &current_time, abstime, &difference );
timeout = _Timespec_To_ticks( &difference );
break;
case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:
already_timedout = FALSE;
break;
}
return _POSIX_Condition_variables_Wait_support(
cond,
mutex,
timeout,
ticks,
already_timedout
);
}

1
cpukit/posix/src/mqueuereceive.c
View File

@@ -51,6 +51,7 @@ ssize_t mq_receive(
msg_ptr,
msg_len,
msg_prio,
TRUE,
THREAD_QUEUE_WAIT_FOREVER
);
}

18
cpukit/posix/src/mqueuerecvsupp.c
View File

@@ -32,8 +32,7 @@
#include <rtems/posix/mqueue.h>
#include <rtems/posix/time.h>
/*PAGE
*
/*
* _POSIX_Message_queue_Receive_support
*
* NOTE: XXX Document how size, priority, length, and the buffer go
@@ -45,6 +44,7 @@ ssize_t _POSIX_Message_queue_Receive_support(
char *msg_ptr,
size_t msg_len,
unsigned int *msg_prio,
boolean wait,
Watchdog_Interval timeout
)
{
@@ -52,6 +52,7 @@ ssize_t _POSIX_Message_queue_Receive_support(
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
size_t length_out;
boolean do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
@@ -81,12 +82,23 @@ ssize_t _POSIX_Message_queue_Receive_support(
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,
mqdes,
msg_ptr,
&length_out,
(the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE,
do_wait,
timeout
);

1
cpukit/posix/src/mqueuesend.c
View File

@@ -51,6 +51,7 @@ int mq_send(
msg_ptr,
msg_len,
msg_prio,
TRUE,
THREAD_QUEUE_WAIT_FOREVER
);
}

15
cpukit/posix/src/mqueuesendsupp.c
View File

@@ -43,6 +43,7 @@ int _POSIX_Message_queue_Send_support(
const char *msg_ptr,
size_t msg_len,
uint32_t msg_prio,
boolean wait,
Watchdog_Interval timeout
)
{
@@ -50,6 +51,7 @@ int _POSIX_Message_queue_Send_support(
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
CORE_message_queue_Status msg_status;
boolean do_wait;
/*
* Validate the priority.
@@ -77,6 +79,17 @@ int _POSIX_Message_queue_Send_support(
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,
msg_ptr,
@@ -88,7 +101,7 @@ int _POSIX_Message_queue_Send_support(
NULL,
#endif
_POSIX_Message_queue_Priority_to_core( msg_prio ),
(the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE,
do_wait,
timeout /* no timeout */
);

28
cpukit/posix/src/mqueuetimedreceive.c
View File

@@ -53,14 +53,38 @@ ssize_t mq_timedreceive(
char *msg_ptr,
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,
msg_ptr,
msg_len,
msg_prio,
_Timespec_To_ticks( timeout )
do_wait,
ticks
);
}

28
cpukit/posix/src/mqueuetimedsend.c
View File

@@ -53,14 +53,38 @@ int mq_timedsend(
const char *msg_ptr,
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,
msg_ptr,
msg_len,
msg_prio,
_Timespec_To_ticks( timeout )
do_wait,
ticks
);
}

2
cpukit/posix/src/mutexfromcorestatus.c
View File

@@ -41,7 +41,7 @@ int _POSIX_Mutex_From_core_mutex_status(
case CORE_MUTEX_WAS_DELETED:
return EINVAL;
case CORE_MUTEX_TIMEOUT:
return EAGAIN;
return ETIMEDOUT;
case CORE_MUTEX_STATUS_CEILING_VIOLATED:
return EINVAL;
default:

59
cpukit/posix/src/mutextimedlock.c
View File

@@ -39,13 +39,58 @@
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *timeout
const struct timespec *abstime
)
{
/* XXX does timeout need to be based on CLOCK_REALTIME and be TOD? */
return _POSIX_Mutex_Lock_support(
mutex,
TRUE,
_Timespec_To_ticks( timeout )
);
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,
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;
}

44
cpukit/posix/src/posixtimespecabsolutetimeout.c
View File

@@ -34,7 +34,7 @@
/*
* The abstime is a walltime. We turn it into an interval.
*/
int _POSIX_Absolute_timeout_to_ticks(
POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks(
const struct timespec *abstime,
Watchdog_Interval *ticks_out
)
@@ -42,21 +42,47 @@ int _POSIX_Absolute_timeout_to_ticks(
struct timespec current_time;
struct timespec difference;
if ( !_Timespec_Is_valid(abstime) )
return EINVAL;
_TOD_Get( &current_time );
/*
* Make sure the abstime is in the future
* Make sure there is always a value returned.
*/
if ( _Timespec_Less_than( abstime, &current_time ) )
return EINVAL;
*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?
*/
_TOD_Get( &current_time );
if ( _Timespec_Less_than( abstime, &current_time ) )
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
/*
* How long until the requested absolute time?
*/
_Timespec_Subtract( &current_time, abstime, &difference );
/*
* Internally the SuperCore uses ticks, so convert to them.
*/
*ticks_out = _Timespec_To_ticks( &difference );
return 0;
/*
* 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;
}

39
cpukit/posix/src/prwlocktimedrdlock.c
View File

@@ -43,14 +43,32 @@ int pthread_rwlock_timedrdlock(
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
Watchdog_Interval ticks;
int status;
boolean do_wait;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
/*
* 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 );
if ( status )
return status;
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;
}
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
@@ -64,12 +82,25 @@ int pthread_rwlock_timedrdlock(
_CORE_RWLock_Obtain_for_reading(
&the_rwlock->RWLock,
*rwlock,
TRUE, // we are willing to wait up to ticks
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
switch (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_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
);

39
cpukit/posix/src/prwlocktimedwrlock.c
View File

@@ -42,15 +42,33 @@ int pthread_rwlock_timedwrlock(
{
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
int status;
Watchdog_Interval ticks;
boolean do_wait;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
/*
* 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 );
if ( status )
return status;
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;
}
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
@@ -64,12 +82,25 @@ int pthread_rwlock_timedwrlock(
_CORE_RWLock_Obtain_for_writing(
&the_rwlock->RWLock,
*rwlock,
TRUE, // we are willing to wait up to ticks
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
switch (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_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
);

5
cpukit/posix/src/semaphorewaitsupp.c
View File

@@ -27,7 +27,7 @@
int _POSIX_Semaphore_Wait_support(
sem_t *sem,
Core_semaphore_Blocking_option blocking,
boolean blocking,
Watchdog_Interval timeout
)
{
@@ -65,9 +65,6 @@ int _POSIX_Semaphore_Wait_support(
* count to the largest value the count can hold.
*/
break;
case CORE_SEMAPHORE_BAD_TIMEOUT_VALUE:
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
}
return 0;

59
cpukit/posix/src/semtimedwait.c
View File

@@ -39,32 +39,51 @@ int sem_timedwait(
const struct timespec *abstime
)
{
/*
* 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 ( !_Timespec_Is_valid( abstime ) ) {
blocking = CORE_SEMAPHORE_BAD_TIMEOUT_VALUE;
} else {
_TOD_Get( &current_time );
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 );
/*
* Make sure the abstime is in the future
* 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 ( _Timespec_Less_than( abstime, &current_time ) ) {
blocking = CORE_SEMAPHORE_BAD_TIMEOUT;
} else {
_Timespec_Subtract( &current_time, abstime, &difference );
ticks = _Timespec_To_ticks( &difference );
blocking = CORE_SEMAPHORE_BLOCK_WITH_TIMEOUT;
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;
}

6
cpukit/posix/src/semwait.c
View File

@@ -31,9 +31,5 @@ int sem_wait(
sem_t *sem
)
{
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 );
}

9
cpukit/posix/src/sigtimedwait.c
View File

@@ -63,16 +63,21 @@ int sigtimedwait(
/*
* Error check parameters before disabling interrupts.
*
* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
if ( !_Timespec_Is_valid( timeout ) ) {
if ( !_Timespec_Is_valid( timeout ) )
rtems_set_errno_and_return_minus_one( EINVAL );
}
interval = _Timespec_To_ticks( timeout );
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
}
/*

3
cpukit/rtems/src/semobtain.c
View File

@@ -107,8 +107,7 @@ rtems_status_code rtems_semaphore_obtain(
_CORE_semaphore_Seize_isr_disable(
&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
);

3
cpukit/rtems/src/semtranslatereturncode.c
View File

@@ -103,7 +103,6 @@ rtems_status_code _Semaphore_Translate_core_semaphore_return_code_[] = {
RTEMS_OBJECT_WAS_DELETED, /* CORE_SEMAPHORE_WAS_DELETED */
RTEMS_TIMEOUT, /* CORE_SEMAPHORE_TIMEOUT */
RTEMS_INTERNAL_ERROR, /* CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED */
RTEMS_INTERNAL_ERROR /* CORE_SEMAPHORE_BAD_TIMEOUT_VALUE */
};
rtems_status_code _Semaphore_Translate_core_semaphore_return_code (
@@ -114,7 +113,7 @@ rtems_status_code _Semaphore_Translate_core_semaphore_return_code (
if ( status == THREAD_STATUS_PROXY_BLOCKING )
return RTEMS_PROXY_BLOCKING;
#endif
if ( status > CORE_SEMAPHORE_BAD_TIMEOUT_VALUE )
if ( status > CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED )
return RTEMS_INTERNAL_ERROR;
return _Semaphore_Translate_core_semaphore_return_code_[status];
}

32
cpukit/score/include/rtems/score/coresem.h
View File

@@ -82,14 +82,7 @@ typedef enum {
/** This status indicates that an attempt was made to unlock the semaphore
* 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;
/**
@@ -122,25 +115,6 @@ typedef struct {
uint32_t count;
} CORE_semaphore_Control;
/**
* 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.
*
@@ -163,14 +137,14 @@ void _CORE_semaphore_Initialize(
* @param[in] the_semaphore is the semaphore to seize
* @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,
boolean wait,
Watchdog_Interval timeout
);

19
cpukit/score/src/coresemseize.c
View File

@@ -53,7 +53,7 @@
void _CORE_semaphore_Seize(
CORE_semaphore_Control *the_semaphore,
Objects_Id id,
Core_semaphore_Blocking_option wait,
boolean wait,
Watchdog_Interval timeout
)
{
@@ -69,23 +69,20 @@ void _CORE_semaphore_Seize(
return;
}
switch ( wait ) {
case CORE_SEMAPHORE_NO_WAIT:
if ( !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:
}
/*
* 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 );
break;
}
}