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

posix: Require struct _pthread_cleanup_context

Browse Source 
This structure is available in Newlib since 2013-11-29 (Git commit
a534dfd26e765047621acd0eda656ded886e7108).
This commit is contained in:
Sebastian Huber
2015-11-24 15:58:26 +01:00
parent d62dfc7d99
commit f6a1ef9fdb
7 changed files with 1 additions and 175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
cpukit/configure.ac
View File

@@ -173,7 +173,7 @@ AC_CHECK_HEADER([pthread.h],[
AC_CHECK_TYPES([pthread_rwlock_t]) AC_CHECK_TYPES([pthread_rwlock_t])
AC_CHECK_TYPES([pthread_barrier_t]) AC_CHECK_TYPES([pthread_barrier_t])
AC_CHECK_TYPES([pthread_spinlock_t]) AC_CHECK_TYPES([pthread_spinlock_t])
AC_CHECK_TYPES([struct _pthread_cleanup_context],[],[],[#include <pthread.h>]) AC_CHECK_TYPES([struct _pthread_cleanup_context],[],[AC_MSG_ERROR([struct _pthread_cleanup_context in <pthread.h> is mandatory])],[#include <pthread.h>])
]) ])
AC_CHECK_HEADER([signal.h],[ AC_CHECK_HEADER([signal.h],[

14
cpukit/posix/include/rtems/posix/cancel.h
View File

@@ -21,20 +21,6 @@
#include <rtems/posix/threadsup.h> #include <rtems/posix/threadsup.h>
#ifndef HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT
/**
* This structure is used to manage the cancelation handlers.
*/
typedef struct {
/** This field is the Chain Node so we can put these on lists. */
Chain_Node Node;
/** This field is the cancelation routine. */
void (*routine)( void * );
/** This field is the argument to the cancelation routine. */
void *arg;
} POSIX_Cancel_Handler_control;
#endif /* HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT */
/** /**
* @brief POSIX run thread cancelation. * @brief POSIX run thread cancelation.
* *

6
cpukit/posix/include/rtems/posix/threadsup.h
View File

@@ -85,16 +85,10 @@ typedef struct {
int cancelability_type; int cancelability_type;
/** This indicates if a cancelation has been requested. */ /** This indicates if a cancelation has been requested. */
int cancelation_requested; int cancelation_requested;
#ifndef HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT
/** This is the set of cancelation handlers. */
Chain_Control Cancellation_Handlers;
#else /* HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT */
/** /**
* @brief LIFO list of cleanup contexts. * @brief LIFO list of cleanup contexts.
*/ */
struct _pthread_cleanup_context *last_cleanup_context; struct _pthread_cleanup_context *last_cleanup_context;
#endif /* HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT */
} POSIX_API_Control; } POSIX_API_Control;
/** /**

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

@@ -25,43 +25,6 @@
#include <rtems/posix/cancel.h> #include <rtems/posix/cancel.h>
#include <rtems/posix/threadsup.h> #include <rtems/posix/threadsup.h>
#ifndef HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT
#include <rtems/score/chainimpl.h>
#include <rtems/score/isr.h>
#include <rtems/score/wkspace.h>
#include <rtems/posix/pthreadimpl.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
POSIX_Cancel_Handler_control *handler;
Chain_Control *handler_stack;
POSIX_API_Control *thread_support;
ISR_Level level;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
_ISR_Disable( level );
handler = (POSIX_Cancel_Handler_control *)
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
(*handler->routine)( handler->arg );
_Workspace_Free( handler );
}
}
#else /* HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT */
void _POSIX_Threads_cancel_run( void _POSIX_Threads_cancel_run(
Thread_Control *the_thread Thread_Control *the_thread
) )
@@ -85,5 +48,3 @@ void _POSIX_Threads_cancel_run(
context = context->_previous; context = context->_previous;
} }
} }
#endif /* HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT */

62
cpukit/posix/src/cleanuppop.c
View File

@@ -24,66 +24,6 @@
#include <rtems/score/threaddispatch.h> #include <rtems/score/threaddispatch.h>
#include <rtems/posix/threadsup.h> #include <rtems/posix/threadsup.h>
#ifndef HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT
#include <rtems/score/chainimpl.h>
#include <rtems/score/isr.h>
#include <rtems/score/wkspace.h>
#include <rtems/posix/cancel.h>
#include <rtems/posix/pthreadimpl.h>
/*
* 18.2.3.1 Establishing Cancellation Handlers, P1003.1c/Draft 10, p. 184
*/
void pthread_cleanup_pop(
int execute
)
{
POSIX_Cancel_Handler_control *handler;
POSIX_Cancel_Handler_control tmp_handler;
Chain_Control *handler_stack;
POSIX_API_Control *thread_support;
ISR_Level level;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
handler_stack = &thread_support->Cancellation_Handlers;
/*
* We need interrupts disabled to safely check the chain and pull
* the last element off. But we also need dispatching disabled to
* ensure that we do not get prempted and deleted while we are holding
* memory that needs to be freed.
*/
_Thread_Disable_dispatch();
_ISR_Disable( level );
if ( _Chain_Is_empty( handler_stack ) ) {
_Thread_Enable_dispatch();
_ISR_Enable( level );
return;
}
handler = (POSIX_Cancel_Handler_control *)
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
tmp_handler = *handler;
_Workspace_Free( handler );
_Thread_Enable_dispatch();
if ( execute )
(*tmp_handler.routine)( tmp_handler.arg );
}
#else /* HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT */
void _pthread_cleanup_pop( void _pthread_cleanup_pop(
struct _pthread_cleanup_context *context, struct _pthread_cleanup_context *context,
int execute int execute
@@ -102,5 +42,3 @@ void _pthread_cleanup_pop(
_Thread_Enable_dispatch(); _Thread_Enable_dispatch();
} }
#endif /* HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT */

49
cpukit/posix/src/cleanuppush.c
View File

@@ -24,53 +24,6 @@
#include <rtems/score/threaddispatch.h> #include <rtems/score/threaddispatch.h>
#include <rtems/posix/threadsup.h> #include <rtems/posix/threadsup.h>
#ifndef HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT
#include <rtems/score/chainimpl.h>
#include <rtems/score/isr.h>
#include <rtems/score/wkspace.h>
#include <rtems/posix/cancel.h>
#include <rtems/posix/pthreadimpl.h>
/*
* 18.2.3.1 Establishing Cancellation Handlers, P1003.1c/Draft 10, p. 184
*/
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
POSIX_Cancel_Handler_control *handler;
Chain_Control *handler_stack;
POSIX_API_Control *thread_support;
/*
* The POSIX standard does not address what to do when the routine
* is NULL. It also does not address what happens when we cannot
* allocate memory or anything else bad happens.
*/
if ( !routine )
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
if ( handler ) {
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
handler_stack = &thread_support->Cancellation_Handlers;
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
}
#else /* HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT */
void _pthread_cleanup_push( void _pthread_cleanup_push(
struct _pthread_cleanup_context *context, struct _pthread_cleanup_context *context,
void ( *routine )( void * ), void ( *routine )( void * ),
@@ -93,5 +46,3 @@ void _pthread_cleanup_push(
_Thread_Enable_dispatch(); _Thread_Enable_dispatch();
} }
#endif /* HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT */

4
cpukit/posix/src/pthread.c
View File

@@ -209,11 +209,7 @@ static bool _POSIX_Threads_Create_extension(
api->cancelation_requested = 0; api->cancelation_requested = 0;
api->cancelability_state = PTHREAD_CANCEL_ENABLE; api->cancelability_state = PTHREAD_CANCEL_ENABLE;
api->cancelability_type = PTHREAD_CANCEL_DEFERRED; api->cancelability_type = PTHREAD_CANCEL_DEFERRED;
#ifndef HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT
_Chain_Initialize_empty (&api->Cancellation_Handlers);
#else /* HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT */
api->last_cleanup_context = NULL; api->last_cleanup_context = NULL;
#endif /* HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT */
/* /*
* If the thread is not a posix thread, then all posix signals are blocked * If the thread is not a posix thread, then all posix signals are blocked