int pthread_mutex_getprioceiling( pthread_mutex_t *mutex, int *prioceiling ) { register POSIX_Mutex_Control *the_mutex; Objects_Locations location; if ( !prioceiling ) return EINVAL; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { case OBJECTS_LOCAL: *prioceiling = _POSIX_Priority_From_core( the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); return 0; #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: #endif case OBJECTS_ERROR: break; } return EINVAL; }
int pthread_mutex_setprioceiling( pthread_mutex_t *mutex, int prioceiling, int *old_ceiling ) { register POSIX_Mutex_Control *the_mutex; Objects_Locations location; Priority_Control the_priority; int status; if ( !old_ceiling ) return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) return EINVAL; the_priority = _POSIX_Priority_To_core( prioceiling ); /* * Must acquire the mutex before we can change it's ceiling */ status = pthread_mutex_lock( mutex ); if ( status ) return status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { case OBJECTS_REMOTE: #if defined(RTEMS_MULTIPROCESSING) /* XXX It feels questionable to set the ceiling on a remote mutex. */ return EINVAL; #endif case OBJECTS_ERROR: return EINVAL; /* impossible to get here */ case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; _CORE_mutex_Surrender( &the_mutex->Mutex, the_mutex->Object.id, #if defined(RTEMS_MULTIPROCESSING) _POSIX_Threads_mutex_MP_support #else NULL #endif ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); }
int pthread_mutex_setprioceiling( pthread_mutex_t *mutex, int prioceiling, int *old_ceiling ) { register POSIX_Mutex_Control *the_mutex; Priority_Control the_priority; ISR_lock_Context lock_context; if ( !old_ceiling ) return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) return EINVAL; the_priority = _POSIX_Priority_To_core( prioceiling ); /* * Must acquire the mutex before we can change it's ceiling. * POSIX says block until we acquire it. */ (void) pthread_mutex_lock( mutex ); /* * Do not worry about the return code from this. The Get operation * will also fail if it is a bad id or was deleted between the two * operations. * * NOTE: This makes it easier to get 100% binary coverage since the * bad Id case is handled by the switch. */ the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &lock_context ); if ( the_mutex == NULL ) { return EINVAL; } *old_ceiling = _POSIX_Priority_From_core( the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; /* * We are required to unlock the mutex before we return. */ _CORE_mutex_Surrender( &the_mutex->Mutex, NULL, 0, &lock_context ); return 0; }
int pthread_getschedparam( pthread_t thread, int *policy, struct sched_param *param ) { Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) return EINVAL; the_thread = _Thread_Get( thread, &location ); switch ( location ) { case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( policy ) *policy = api->schedpolicy; if ( param ) { *param = api->schedparam; param->sched_priority = _POSIX_Priority_From_core( the_thread->current_priority ); } _Objects_Put( &the_thread->Object ); return 0; #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: #endif case OBJECTS_ERROR: break; } return ESRCH; }
int pthread_getschedparam( pthread_t thread, int *policy, struct sched_param *param ) { Thread_Control *the_thread; Thread_queue_Context queue_context; POSIX_API_Control *api; const Scheduler_Control *scheduler; Priority_Control priority; if ( policy == NULL || param == NULL ) { return EINVAL; } the_thread = _Thread_Get( thread, &queue_context.Lock_context ); if ( the_thread == NULL ) { return ESRCH; } api = the_thread->API_Extensions[ THREAD_API_POSIX ]; _Thread_Wait_acquire_critical( the_thread, &queue_context ); *policy = api->Attributes.schedpolicy; *param = api->Attributes.schedparam; scheduler = _Scheduler_Get_own( the_thread ); priority = the_thread->real_priority; _Thread_Wait_release( the_thread, &queue_context ); param->sched_priority = _POSIX_Priority_From_core( scheduler, priority ); return 0; }
int pthread_mutex_setprioceiling( pthread_mutex_t *mutex, int prioceiling, int *old_ceiling ) { register POSIX_Mutex_Control *the_mutex; Objects_Locations location; Priority_Control the_priority; ISR_lock_Context lock_context; if ( !old_ceiling ) return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) return EINVAL; the_priority = _POSIX_Priority_To_core( prioceiling ); /* * Must acquire the mutex before we can change it's ceiling. * POSIX says block until we acquire it. */ (void) pthread_mutex_lock( mutex ); /* * Do not worry about the return code from this. The Get operation * will also fail if it is a bad id or was deleted between the two * operations. * * NOTE: This makes it easier to get 100% binary coverage since the * bad Id case is handled by the switch. */ the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &lock_context ); switch ( location ) { case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; /* * We are required to unlock the mutex before we return. */ _CORE_mutex_Surrender( &the_mutex->Mutex, the_mutex->Object.id, NULL, &lock_context ); return 0; #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible to get here */ #endif case OBJECTS_ERROR: break; } return EINVAL; }
Thread_Control *executing RTEMS_UNUSED, Thread_Control *created ) { POSIX_API_Control *api; POSIX_API_Control *executing_api; api = created->API_Extensions[ THREAD_API_POSIX ]; /* XXX check all fields are touched */ _POSIX_Threads_Initialize_attributes( &api->Attributes ); api->detachstate = _POSIX_Threads_Default_attributes.detachstate; api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; api->schedparam = _POSIX_Threads_Default_attributes.schedparam; api->schedparam.sched_priority = _POSIX_Priority_From_core( created->current_priority ); /* * POSIX 1003.1 1996, 18.2.2.2 */ api->cancelation_requested = 0; api->cancelability_state = PTHREAD_CANCEL_ENABLE; 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; #endif /* HAVE_STRUCT__PTHREAD_CLEANUP_CONTEXT */ /* * If the thread is not a posix thread, then all posix signals are blocked