generic-library/bionic
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

am 3069270d: am c2bba24d: Merge "Give the timer_create SIGEV_THREAD helper threads sensible names."

Browse Source 
* commit '3069270d8641c7bb57aa308d8f90b4d2dcbf66fc':
  Give the timer_create SIGEV_THREAD helper threads sensible names.
This commit is contained in:
Elliott Hughes 2012-06-06 11:37:25 -07:00 committed by Android Git Automerger
commit 158ad015c2
2 changed files with 217 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
libc/Android.mk
View File

@ -446,18 +446,19 @@ endif # !arm
# Define some common cflags # Define some common cflags
# ======================================================== # ========================================================
libc_common_cflags := \ libc_common_cflags := \
-DWITH_ERRLIST \ -DWITH_ERRLIST \
-DANDROID_CHANGES \ -DANDROID_CHANGES \
-DUSE_LOCKS \ -DUSE_LOCKS \
-DREALLOC_ZERO_BYTES_FREES \ -DREALLOC_ZERO_BYTES_FREES \
-D_LIBC=1 \ -D_LIBC=1 \
-DSOFTFLOAT \ -DSOFTFLOAT \
-DFLOATING_POINT \ -DFLOATING_POINT \
-DINET6 \ -DINET6 \
-I$(LOCAL_PATH)/private \ -I$(LOCAL_PATH)/private \
-DUSE_DL_PREFIX \ -DUSE_DL_PREFIX \
-DPOSIX_MISTAKE \ -DPOSIX_MISTAKE \
-DLOG_ON_HEAP_ERROR \ -DLOG_ON_HEAP_ERROR \
-std=gnu99
# these macro definitions are required to implement the # these macro definitions are required to implement the
# 'timezone' and 'daylight' global variables, as well as # 'timezone' and 'daylight' global variables, as well as

441
libc/bionic/pthread-timers.c
View File

@ -9,7 +9,7 @@
* notice, this list of conditions and the following disclaimer. * notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright * * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in * notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the * the documentation and/or other materials provided with the
* distribution. * distribution.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
@ -19,55 +19,56 @@
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE. * SUCH DAMAGE.
*/ */
#include "pthread_internal.h" #include "pthread_internal.h"
#include <linux/time.h>
#include <string.h>
#include <errno.h> #include <errno.h>
#include <linux/time.h>
#include <stdio.h>
#include <string.h>
/* This file implements the support required to implement SIGEV_THREAD posix // Normal (i.e. non-SIGEV_THREAD) timers are created directly by the kernel
* timers. See the following pages for additionnal details: // and are passed as is to/from the caller.
* //
* www.opengroup.org/onlinepubs/000095399/functions/timer_create.html // This file also implements the support required for SIGEV_THREAD ("POSIX interval")
* www.opengroup.org/onlinepubs/000095399/functions/timer_settime.html // timers. See the following pages for additional details:
* www.opengroup.org/onlinepubs/000095399/functions/xsh_chap02_04.html#tag_02_04_01 //
* // www.opengroup.org/onlinepubs/000095399/functions/timer_create.html
* The Linux kernel doesn't support these, so we need to implement them in the // www.opengroup.org/onlinepubs/000095399/functions/timer_settime.html
* C library. We use a very basic scheme where each timer is associated to a // www.opengroup.org/onlinepubs/000095399/functions/xsh_chap02_04.html#tag_02_04_01
* thread that will loop, waiting for timeouts or messages from the program //
* corresponding to calls to timer_settime() and timer_delete(). // The Linux kernel doesn't support these, so we need to implement them in the
* // C library. We use a very basic scheme where each timer is associated to a
* Note also an important thing: Posix mandates that in the case of fork(), // thread that will loop, waiting for timeouts or messages from the program
* the timers of the child process should be disarmed, but not deleted. // corresponding to calls to timer_settime() and timer_delete().
* this is implemented by providing a fork() wrapper (see bionic/fork.c) which //
* stops all timers before the fork, and only re-start them in case of error // Note also an important thing: Posix mandates that in the case of fork(),
* or in the parent process. // the timers of the child process should be disarmed, but not deleted.
* // this is implemented by providing a fork() wrapper (see bionic/fork.c) which
* the stop/start is implemented by the __timer_table_start_stop() function // stops all timers before the fork, and only re-start them in case of error
* below. // or in the parent process.
*/ //
// This stop/start is implemented by the __timer_table_start_stop() function
/* normal (i.e. non-SIGEV_THREAD) timer ids are created directly by the kernel // below.
* and are passed as is to/from the caller. //
* // A SIGEV_THREAD timer ID will always have its TIMER_ID_WRAP_BIT
* on the other hand, a SIGEV_THREAD timer ID will have its TIMER_ID_WRAP_BIT // set to 1. In this implementation, this is always bit 31, which is
* always set to 1. In this implementation, this is always bit 31, which is // guaranteed to never be used by kernel-provided timer ids
* guaranteed to never be used by kernel-provided timer ids //
* // (See code in <kernel>/lib/idr.c, used to manage IDs, to see why.)
* (see code in <kernel>/lib/idr.c, used to manage IDs, to see why)
*/
#define TIMER_ID_WRAP_BIT 0x80000000 #define TIMER_ID_WRAP_BIT 0x80000000
#define TIMER_ID_WRAP(id) ((timer_t)((id) | TIMER_ID_WRAP_BIT)) #define TIMER_ID_WRAP(id) ((timer_t)((id) | TIMER_ID_WRAP_BIT))
#define TIMER_ID_UNWRAP(id) ((timer_t)((id) & ~TIMER_ID_WRAP_BIT)) #define TIMER_ID_UNWRAP(id) ((timer_t)((id) & ~TIMER_ID_WRAP_BIT))
#define TIMER_ID_IS_WRAPPED(id) (((id) & TIMER_ID_WRAP_BIT) != 0) #define TIMER_ID_IS_WRAPPED(id) (((id) & TIMER_ID_WRAP_BIT) != 0)
/* this value is used internally to indicate a 'free' or 'zombie' /* this value is used internally to indicate a 'free' or 'zombie'
* thr_timer structure. Here, 'zombie' means that timer_delete() * thr_timer structure. Here, 'zombie' means that timer_delete()
* has been called, but that the corresponding thread hasn't * has been called, but that the corresponding thread hasn't
* exited yet. * exited yet.
@ -171,25 +172,23 @@ thr_timer_table_free( thr_timer_table_t* t, thr_timer_t* timer )
} }
static void static void thr_timer_table_start_stop(thr_timer_table_t* t, int stop) {
thr_timer_table_start_stop( thr_timer_table_t* t, int stop ) if (t == NULL) {
{ return;
int nn; }
pthread_mutex_lock(&t->lock); pthread_mutex_lock(&t->lock);
for (int nn = 0; nn < MAX_THREAD_TIMERS; ++nn) {
for (nn = 0; nn < MAX_THREAD_TIMERS; nn++) { thr_timer_t* timer = &t->timers[nn];
thr_timer_t* timer = &t->timers[nn]; if (TIMER_ID_IS_VALID(timer->id)) {
// Tell the thread to start/stop.
if (TIMER_ID_IS_VALID(timer->id)) { pthread_mutex_lock(&timer->mutex);
/* tell the thread to start/stop */ timer->stopped = stop;
pthread_mutex_lock(&timer->mutex); pthread_cond_signal( &timer->cond );
timer->stopped = stop; pthread_mutex_unlock(&timer->mutex);
pthread_cond_signal( &timer->cond );
pthread_mutex_unlock(&timer->mutex);
}
} }
pthread_mutex_unlock(&t->lock); }
pthread_mutex_unlock(&t->lock);
} }
@ -234,23 +233,19 @@ thr_timer_table_from_id( thr_timer_table_t* t,
* pretty infrequent * pretty infrequent
*/ */
static pthread_once_t __timer_table_once = PTHREAD_ONCE_INIT; static pthread_once_t __timer_table_once = PTHREAD_ONCE_INIT;
static thr_timer_table_t* __timer_table; static thr_timer_table_t* __timer_table;
static void static void __timer_table_init(void) {
__timer_table_init( void ) __timer_table = calloc(1, sizeof(*__timer_table));
{ if (__timer_table != NULL) {
__timer_table = calloc(1,sizeof(*__timer_table)); thr_timer_table_init(__timer_table);
}
if (__timer_table != NULL)
thr_timer_table_init( __timer_table );
} }
static thr_timer_table_t* static thr_timer_table_t* __timer_table_get(void) {
__timer_table_get(void) pthread_once(&__timer_table_once, __timer_table_init);
{ return __timer_table;
pthread_once( &__timer_table_once, __timer_table_init );
return __timer_table;
} }
/** POSIX THREAD TIMERS CLEANUP ON FORK /** POSIX THREAD TIMERS CLEANUP ON FORK
@ -260,13 +255,9 @@ __timer_table_get(void)
** requirements: the timers of fork child processes must be ** requirements: the timers of fork child processes must be
** disarmed but not deleted. ** disarmed but not deleted.
**/ **/
__LIBC_HIDDEN__ void __LIBC_HIDDEN__ void __timer_table_start_stop(int stop) {
__timer_table_start_stop( int stop ) // We access __timer_table directly so we don't create it if it doesn't yet exist.
{ thr_timer_table_start_stop(__timer_table, stop);
if (__timer_table != NULL) {
thr_timer_table_t* table = __timer_table_get();
thr_timer_table_start_stop(table, stop);
}
} }
static thr_timer_t* static thr_timer_t*
@ -293,85 +284,76 @@ thr_timer_unlock( thr_timer_t* t )
/** POSIX TIMERS APIs */ /** POSIX TIMERS APIs */
/* first, declare the syscall stubs */ extern int __timer_create(clockid_t, struct sigevent*, timer_t*);
extern int __timer_create( clockid_t, struct sigevent*, timer_t* ); extern int __timer_delete(timer_t);
extern int __timer_delete( timer_t ); extern int __timer_gettime(timer_t, struct itimerspec*);
extern int __timer_gettime( timer_t, struct itimerspec* ); extern int __timer_settime(timer_t, int, const struct itimerspec*, struct itimerspec*);
extern int __timer_settime( timer_t, int, const struct itimerspec*, struct itimerspec* );
extern int __timer_getoverrun(timer_t); extern int __timer_getoverrun(timer_t);
static void* timer_thread_start( void* ); static void* timer_thread_start(void*);
/* then the wrappers themselves */ int timer_create(clockid_t clock_id, struct sigevent* evp, timer_t* timer_id) {
int // If not a SIGEV_THREAD timer, the kernel can handle it without our help.
timer_create( clockid_t clockid, struct sigevent* evp, timer_t *ptimerid) if (__likely(evp == NULL || evp->sigev_notify != SIGEV_THREAD)) {
{ return __timer_create(clock_id, evp, timer_id);
/* if not a SIGEV_THREAD timer, direct creation by the kernel */ }
if (__likely(evp == NULL || evp->sigev_notify != SIGEV_THREAD))
return __timer_create( clockid, evp, ptimerid );
// check arguments // Check arguments.
if (evp->sigev_notify_function == NULL) { if (evp->sigev_notify_function == NULL) {
errno = EINVAL; errno = EINVAL;
return -1; return -1;
} }
{ // Check that the clock id is supported by the kernel.
struct timespec dummy; struct timespec dummy;
if (clock_gettime(clock_id, &dummy) < 0 && errno == EINVAL) {
return -1;
}
/* check that the clock id is supported by the kernel */ // Create a new timer and its thread.
if (clock_gettime( clockid, &dummy ) < 0 && errno == EINVAL ) // TODO: use a single global thread for all timers.
return -1; thr_timer_table_t* table = __timer_table_get();
} thr_timer_t* timer = thr_timer_table_alloc(table);
if (timer == NULL) {
errno = ENOMEM;
return -1;
}
/* create a new timer and its thread */ // Copy the thread attributes.
{ if (evp->sigev_notify_attributes == NULL) {
thr_timer_table_t* table = __timer_table_get(); pthread_attr_init(&timer->attributes);
thr_timer_t* timer = thr_timer_table_alloc( table ); } else {
struct sigevent evp0; timer->attributes = ((pthread_attr_t*) evp->sigev_notify_attributes)[0];
}
if (timer == NULL) { // Posix says that the default is PTHREAD_CREATE_DETACHED and
errno = ENOMEM; // that PTHREAD_CREATE_JOINABLE has undefined behavior.
return -1; // So simply always use DETACHED :-)
} pthread_attr_setdetachstate(&timer->attributes, PTHREAD_CREATE_DETACHED);
/* copy the thread attributes */ timer->callback = evp->sigev_notify_function;
if (evp->sigev_notify_attributes == NULL) { timer->value = evp->sigev_value;
pthread_attr_init(&timer->attributes); timer->clock = clock_id;
}
else {
timer->attributes = ((pthread_attr_t*)evp->sigev_notify_attributes)[0];
}
/* Posix says that the default is PTHREAD_CREATE_DETACHED and pthread_mutex_init(&timer->mutex, NULL);
* that PTHREAD_CREATE_JOINABLE has undefined behaviour. pthread_cond_init(&timer->cond, NULL);
* So simply always use DETACHED :-)
*/
pthread_attr_setdetachstate(&timer->attributes, PTHREAD_CREATE_DETACHED);
timer->callback = evp->sigev_notify_function; timer->done = 0;
timer->value = evp->sigev_value; timer->stopped = 0;
timer->clock = clockid; timer->expires.tv_sec = timer->expires.tv_nsec = 0;
timer->period.tv_sec = timer->period.tv_nsec = 0;
timer->overruns = 0;
pthread_mutex_init( &timer->mutex, NULL ); // Create the thread.
pthread_cond_init( &timer->cond, NULL ); int rc = pthread_create(&timer->thread, &timer->attributes, timer_thread_start, timer);
if (rc != 0) {
thr_timer_table_free(table, timer);
errno = rc;
return -1;
}
timer->done = 0; *timer_id = timer->id;
timer->stopped = 0; return 0;
timer->expires.tv_sec = timer->expires.tv_nsec = 0;
timer->period.tv_sec = timer->period.tv_nsec = 0;
timer->overruns = 0;
/* create the thread */
if (pthread_create( &timer->thread, &timer->attributes, timer_thread_start, timer ) < 0) {
thr_timer_table_free( __timer_table, timer );
errno = ENOMEM;
return -1;
}
*ptimerid = timer->id;
return 0;
}
} }
@ -414,7 +396,7 @@ timer_gettime_internal( thr_timer_t* timer,
struct timespec diff; struct timespec diff;
diff = timer->expires; diff = timer->expires;
if (!timespec_is_zero(&diff)) if (!timespec_is_zero(&diff))
{ {
struct timespec now; struct timespec now;
@ -532,108 +514,93 @@ timer_getoverrun(timer_t id)
} }
static void* static void* timer_thread_start(void* arg) {
timer_thread_start( void* _arg ) thr_timer_t* timer = arg;
{
thr_timer_t* timer = _arg;
thr_timer_lock( timer ); thr_timer_lock(timer);
/* we loop until timer->done is set in timer_delete() */ // Give this thread a meaningful name.
while (!timer->done) char name[32];
{ snprintf(name, sizeof(name), "POSIX interval timer 0x%08x", timer->id);
struct timespec expires = timer->expires; pthread_setname_np(pthread_self(), name);
struct timespec period = timer->period;
struct timespec now;
/* if the timer is stopped or disarmed, wait indefinitely // We loop until timer->done is set in timer_delete().
* for a state change from timer_settime/_delete/_start_stop while (!timer->done) {
*/ struct timespec expires = timer->expires;
if ( timer->stopped || timespec_is_zero(&expires) ) struct timespec period = timer->period;
{
pthread_cond_wait( &timer->cond, &timer->mutex );
continue;
}
/* otherwise, we need to do a timed wait until either a // If the timer is stopped or disarmed, wait indefinitely
* state change of the timer expiration time. // for a state change from timer_settime/_delete/_start_stop.
*/ if (timer->stopped || timespec_is_zero(&expires)) {
clock_gettime(timer->clock, &now); pthread_cond_wait(&timer->cond, &timer->mutex);
continue;
if (timespec_cmp( &expires, &now ) > 0)
{
/* cool, there was no overrun, so compute the
* relative timeout as 'expires - now', then wait
*/
int ret;
struct timespec diff = expires;
timespec_sub( &diff, &now );
ret = __pthread_cond_timedwait_relative(
&timer->cond, &timer->mutex, &diff);
/* if we didn't timeout, it means that a state change
* occured, so reloop to take care of it.
*/
if (ret != ETIMEDOUT)
continue;
}
else
{
/* overrun was detected before we could wait ! */
if (!timespec_is_zero( &period ) )
{
/* for periodic timers, compute total overrun count */
do {
timespec_add( &expires, &period );
if (timer->overruns < DELAYTIMER_MAX)
timer->overruns += 1;
} while ( timespec_cmp( &expires, &now ) < 0 );
/* backtrack the last one, because we're going to
* add the same value just a bit later */
timespec_sub( &expires, &period );
}
else
{
/* for non-periodic timer, things are simple */
timer->overruns = 1;
}
}
/* if we get there, a timeout was detected.
* first reload/disarm the timer has needed
*/
if ( !timespec_is_zero(&period) ) {
timespec_add( &expires, &period );
} else {
timespec_zero( &expires );
}
timer->expires = expires;
/* now call the timer callback function. release the
* lock to allow the function to modify the timer setting
* or call timer_getoverrun().
*
* NOTE: at this point we trust the callback not to be a
* total moron and pthread_kill() the timer thread
*/
thr_timer_unlock(timer);
timer->callback( timer->value );
thr_timer_lock(timer);
/* now clear the overruns counter. it only makes sense
* within the callback */
timer->overruns = 0;
} }
thr_timer_unlock( timer ); // Otherwise, we need to do a timed wait until either a
// state change of the timer expiration time.
struct timespec now;
clock_gettime(timer->clock, &now);
/* free the timer object now. there is no need to call if (timespec_cmp(&expires, &now) > 0) {
* __timer_table_get() since we're guaranteed that __timer_table // Cool, there was no overrun, so compute the
* is initialized in this thread // relative timeout as 'expires - now', then wait.
*/ struct timespec diff = expires;
thr_timer_table_free(__timer_table, timer); timespec_sub(&diff, &now);
return NULL; int ret = __pthread_cond_timedwait_relative(&timer->cond, &timer->mutex, &diff);
// If we didn't time out, it means that a state change
// occurred, so loop to take care of it.
if (ret != ETIMEDOUT) {
continue;
}
} else {
// Overrun was detected before we could wait!
if (!timespec_is_zero(&period)) {
// For periodic timers, compute total overrun count.
do {
timespec_add(&expires, &period);
if (timer->overruns < DELAYTIMER_MAX) {
timer->overruns += 1;
}
} while (timespec_cmp(&expires, &now) < 0);
// Backtrack the last one, because we're going to
// add the same value just a bit later.
timespec_sub(&expires, &period);
} else {
// For non-periodic timers, things are simple.
timer->overruns = 1;
}
}
// If we get here, a timeout was detected.
// First reload/disarm the timer as needed.
if (!timespec_is_zero(&period)) {
timespec_add(&expires, &period);
} else {
timespec_zero(&expires);
}
timer->expires = expires;
// Now call the timer callback function. Release the
// lock to allow the function to modify the timer setting
// or call timer_getoverrun().
// NOTE: at this point we trust the callback not to be a
// total moron and pthread_kill() the timer thread
thr_timer_unlock(timer);
timer->callback(timer->value);
thr_timer_lock(timer);
// Now clear the overruns counter. it only makes sense
// within the callback.
timer->overruns = 0;
}
thr_timer_unlock(timer);
// Free the timer object.
thr_timer_table_free(__timer_table_get(), timer);
return NULL;
} }