| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| ************************************************************************ |
| * @file M4OSA_Thread.c |
| * @ingroup OSAL |
| * @brief Implements and manipulate threads |
| * @note This file implements functions to manipulate threads |
| ************************************************************************ |
| */ |
| |
| #include <sched.h> |
| #include <time.h> |
| #include <pthread.h> |
| #include <errno.h> |
| |
| #include <utils/threads.h> |
| #include "M4OSA_Debug.h" |
| #include "M4OSA_Memory.h" |
| #include "M4OSA_Thread.h" |
| #include "M4OSA_Thread_priv.h" |
| #include "M4OSA_Mutex.h" |
| #include "M4OSA_Semaphore.h" |
| #include "M4OSA_CharStar.h" |
| |
| |
| void* M4OSA_threadSyncForEverDo(void *context) |
| { |
| M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context; |
| M4OSA_Bool auto_kill = M4OSA_FALSE; |
| |
| /* |
| M4OSA_Void* userData; |
| */ |
| |
| M4OSA_TRACE2_1("M4OSA_threadSyncForEverDo\t\tLPVOID 0x%x", context); |
| |
| /* |
| userData = threadContext->userData; |
| */ |
| |
| M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER); |
| |
| |
| threadContext->state = M4OSA_kThreadRunning; |
| |
| M4OSA_semaphorePost(threadContext->semStartStop); |
| |
| while(threadContext->state == M4OSA_kThreadRunning) |
| { |
| M4OSA_mutexUnlock(threadContext->stateMutex); |
| |
| if((threadContext->func(threadContext->param)) != M4NO_ERROR) |
| { |
| M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER); |
| |
| if(threadContext->state == M4OSA_kThreadRunning) |
| { |
| |
| //PR 2354 - ACO : Suppress stopping state and don't |
| // unlock mutex before closing the thread |
| threadContext->state = M4OSA_kThreadOpened; |
| M4OSA_mutexUnlock(threadContext->stateMutex); |
| return 0; |
| } |
| |
| M4OSA_mutexUnlock(threadContext->stateMutex); |
| } |
| |
| M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER); |
| } |
| |
| |
| M4OSA_semaphorePost(threadContext->semStartStop); |
| |
| |
| M4OSA_mutexUnlock(threadContext->stateMutex); |
| |
| |
| return 0; |
| } |
| |
| |
| |
| |
| |
| /** |
| ************************************************************************ |
| * @brief This method creates a new thread. After this call the thread is |
| * identified by its "context". The thread function is provided by |
| * the "func" parameter. This function creates & allocates a unique |
| * context. It's the OSAL real time responsibility for managing its |
| * context. It must be freed by the M4OSA_threadSyncClose function. |
| * The context parameter will be sent back to any OSAL core thread |
| * functions to allow retrieving data associated to the opened |
| * thread. |
| * @note This function creates the thread, but the thread is not running. |
| * @note Once the thread is created, the state is M4OSA_kThreadOpened. |
| * @param context:(OUT) Context of the created thread |
| * @param func:(IN) "doIt" function pointer to run |
| * @return M4NO_ERROR: there is no error |
| * @return M4ERR_PARAMETER: at least one parameter is NULL |
| * @return M4ERR_ALLOC: there is no more available memory |
| * @return M4ERR_CONTEXT_FAILED: the context creation failed |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4OSA_threadSyncOpen(M4OSA_Context* context, |
| M4OSA_ThreadDoIt func) |
| { |
| M4OSA_ThreadContext* threadContext = M4OSA_NULL; |
| M4OSA_ERR err_code; |
| |
| M4OSA_TRACE1_2("M4OSA_threadSyncOpen\t\tM4OSA_Context* 0x%x\t" |
| "M4OSA_ThreadDoIt 0x%x", context, func); |
| |
| M4OSA_DEBUG_IF2(context == M4OSA_NULL, |
| M4ERR_PARAMETER, "M4OSA_threadSyncOpen"); |
| |
| M4OSA_DEBUG_IF2(func == M4OSA_NULL, |
| M4ERR_PARAMETER, "M4OSA_threadSyncOpen"); |
| |
| *context = M4OSA_NULL; |
| |
| threadContext = |
| (M4OSA_ThreadContext*)M4OSA_32bitAlignedMalloc(sizeof(M4OSA_ThreadContext), |
| M4OSA_THREAD, (M4OSA_Char*)"M4OSA_threadSyncOpen: thread context"); |
| |
| if(threadContext == M4OSA_NULL) |
| { |
| M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_threadSyncOpen"); |
| |
| return M4ERR_ALLOC; |
| } |
| |
| threadContext->func = func; |
| threadContext->stackSize = 64 * 1024; |
| threadContext->name = M4OSA_NULL; |
| threadContext->threadID = 0; |
| threadContext->coreID = M4OSA_THREAD; |
| threadContext->state = M4OSA_kThreadOpened; |
| threadContext->priority = M4OSA_kThreadNormalPriority ; |
| |
| err_code = M4OSA_mutexOpen(&(threadContext->stateMutex)); |
| |
| if(M4OSA_ERR_IS_ERROR(err_code)) |
| { |
| M4OSA_DEBUG(err_code, "M4OSA_threadSyncOpen: M4OSA_mutexOpen"); |
| |
| return err_code; |
| } |
| |
| err_code = M4OSA_semaphoreOpen(&(threadContext->semStartStop), 0); |
| |
| if(M4OSA_ERR_IS_ERROR(err_code)) |
| { |
| M4OSA_DEBUG(err_code, "M4OSA_threadSyncOpen: M4OSA_semaphoreOpen"); |
| |
| return err_code; |
| } |
| |
| *context = threadContext; |
| |
| return M4NO_ERROR; |
| } |
| |
| |
| |
| |
| |
| /** |
| ************************************************************************ |
| * @brief This method runs a specified thread. The "param" parameter |
| * allows the application to set a specific parameter to the |
| * created thread. This parameter will be used as the second one of |
| * the "M4OSA_ThreadDoIt" function. |
| * @note This method is a blocking up to the thread is running. |
| * Before calling this method, the state is M4OSA_kThreadOpened. |
| * Once the method is called, the state is M4OSA_kThreadStarting. |
| * Once the thread is running, the state is M4OSA_kThreadRunning. |
| * @note This method returns immediately. If the "threadStarted" optionID |
| * is not NULL, the thread will call it before running the doIt |
| * function. |
| * @param context:(IN/OUT) Context of the thread |
| * @param param:(IN) Application data thread parameter |
| * @return M4NO_ERROR: there is no error |
| * @return M4ERR_PARAMETER: at least one parameter is NULL |
| * @return M4ERR_BAD_CONTEXT: provided context is not a valid one |
| * @return M4ERR_STATE: this function cannot be called now |
| * @return M4ERR_THREAD_NOT_STARTED: the thread did not start |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4OSA_threadSyncStart(M4OSA_Context context, |
| M4OSA_Void* param) |
| { |
| M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context; |
| pthread_attr_t attribute = { 0, 0, 0, 0, 0, 0 }; |
| int min = 0; |
| int max = 0; |
| int priority = 0; |
| struct sched_param sched = { 0 }; |
| |
| M4OSA_TRACE1_2("M4OSA_threadSyncStart\t\tM4OSA_Context 0x%x\tM4OSA_Void* " |
| "0x%x", context, param); |
| |
| M4OSA_DEBUG_IF2(context == M4OSA_NULL, |
| M4ERR_PARAMETER, "M4OSA_threadSyncStart"); |
| |
| M4OSA_DEBUG_IF2(threadContext->coreID != M4OSA_THREAD, |
| M4ERR_BAD_CONTEXT, "M4OSA_threadSyncStart"); |
| |
| M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER); |
| |
| if(threadContext->state != M4OSA_kThreadOpened) |
| { |
| M4OSA_mutexUnlock(threadContext->stateMutex); |
| |
| M4OSA_DEBUG(M4ERR_STATE, "M4OSA_threadSyncStart"); |
| |
| return M4ERR_STATE; |
| } |
| |
| threadContext->state = M4OSA_kThreadStarting; |
| |
| M4OSA_mutexUnlock(threadContext->stateMutex); |
| threadContext->param = param; |
| |
| if ( 0 == pthread_attr_init( &attribute ) ) |
| { |
| if ( 0 == pthread_attr_setdetachstate( &attribute, PTHREAD_CREATE_DETACHED ) ) |
| { |
| if ( 0 == pthread_attr_setstacksize( &attribute, (size_t)threadContext->stackSize ) ) |
| { |
| if ( 0 == pthread_attr_setschedpolicy( &attribute, SCHED_OTHER ) ) |
| { |
| /* Tentative patches to handle priorities in a better way : */ |
| /* Use Android's predefined priorities (range +19..-20) |
| *rather than Linux ones (0..99)*/ |
| |
| /* Get min and max priorities */ |
| min = sched_get_priority_min( SCHED_FIFO ); |
| max = sched_get_priority_max( SCHED_FIFO ); |
| |
| M4OSA_TRACE1_2("M4OSA_threadSyncStart MAX=%d MIN=%d", max, min); |
| |
| /* tentative modification of the priorities */ |
| /* Set the priority based on default android priorities */ |
| /* This probably requires some more tuning, |
| * outcome of this priority settings are not yet satisfactory */ |
| /* Implementing thread handling based on Android's thread creation |
| * helpers might bring some improvement (see threads.h) */ |
| switch(threadContext->priority) |
| { |
| case M4OSA_kThreadLowestPriority: |
| priority = ANDROID_PRIORITY_NORMAL; |
| break; |
| case M4OSA_kThreadLowPriority: |
| priority = ANDROID_PRIORITY_DISPLAY; |
| break; |
| case M4OSA_kThreadNormalPriority: |
| priority = ANDROID_PRIORITY_URGENT_DISPLAY; |
| break; |
| case M4OSA_kThreadHighPriority: |
| priority = ANDROID_PRIORITY_AUDIO; |
| break; |
| case M4OSA_kThreadHighestPriority: |
| priority = ANDROID_PRIORITY_URGENT_AUDIO; |
| break; |
| } |
| sched.sched_priority = priority; |
| |
| if ( 0 == pthread_attr_setschedparam( &attribute, &sched ) ) |
| { |
| if ( 0 == pthread_create( &threadContext->threadID, |
| &attribute, |
| &M4OSA_threadSyncForEverDo, |
| (void *)threadContext ) ) |
| { |
| if ( M4OSA_FALSE == M4OSA_ERR_IS_ERROR( M4OSA_semaphoreWait( |
| threadContext->semStartStop, |
| M4OSA_WAIT_FOREVER ) ) ) |
| { |
| return M4NO_ERROR; |
| } |
| } |
| } |
| } |
| } |
| } |
| pthread_attr_destroy( &attribute ); |
| } |
| |
| M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER); |
| |
| threadContext->state = M4OSA_kThreadOpened; |
| |
| M4OSA_mutexUnlock(threadContext->stateMutex); |
| |
| M4OSA_DEBUG(M4ERR_THREAD_NOT_STARTED, "M4OSA_threadSyncStart"); |
| |
| return M4ERR_THREAD_NOT_STARTED; |
| } |
| |
| |
| |
| |
| /** |
| ************************************************************************ |
| * @brief This method stops a specified thread. |
| * @note This call is a blocking one up to the "M4OSA_ThreadDoIt" |
| * function has returned. |
| * Before the method is called, the state is M4OSA_kThreadRunning. |
| * Once the method is called, the state is M4OSA_kThreadStopping. |
| * Once the thread is stopped, the state is M4OSA_kThreadOpened. |
| * @note This method returns once the thread has been stopped. If the |
| * "threadStopped" optionID is not NULL, the thread will call it |
| * before dying. |
| * @param context:(IN/OUT) Context of the thread |
| * @return M4NO_ERROR: there is no error |
| * @return M4ERR_PARAMETER: at least one parameter is NULL |
| * @return M4ERR_STATE: this function cannot be called now |
| * @return M4ERR_BAD_CONTEXT: provided context is not a valid one |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4OSA_threadSyncStop(M4OSA_Context context) |
| { |
| M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context; |
| |
| M4OSA_TRACE1_1("M4OSA_threadSyncStop\t\tM4OSA_Context 0x%x", context); |
| |
| M4OSA_DEBUG_IF2(context == M4OSA_NULL, |
| M4ERR_PARAMETER, "M4OSA_threadSyncStop"); |
| |
| M4OSA_DEBUG_IF2(threadContext->coreID != M4OSA_THREAD, |
| M4ERR_BAD_CONTEXT, "M4OSA_threadSyncStop"); |
| |
| M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER); |
| |
| if(threadContext->state != M4OSA_kThreadRunning) |
| { |
| M4OSA_mutexUnlock(threadContext->stateMutex); |
| |
| M4OSA_DEBUG(M4ERR_STATE, "M4OSA_threadSyncStop"); |
| |
| return M4ERR_STATE; |
| } |
| |
| threadContext->state = M4OSA_kThreadStopping; |
| |
| M4OSA_mutexUnlock(threadContext->stateMutex); |
| |
| M4OSA_semaphoreWait(threadContext->semStartStop, M4OSA_WAIT_FOREVER); |
| |
| M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER); |
| |
| threadContext->state = M4OSA_kThreadOpened; |
| |
| M4OSA_mutexUnlock(threadContext->stateMutex); |
| |
| return M4NO_ERROR; |
| } |
| |
| |
| |
| |
| /** |
| ************************************************************************ |
| * @brief This method deletes a thread (identified by its context). After |
| * this call the thread and its context are no more useable. This |
| * function frees all the memory related to this thread. |
| * @note Before the method is called, the state is M4OSA_kThreadOpened. |
| * Once the method is called, the state is M4OSA_kThreadClosed. |
| * @param context:(IN/OUT) Context of the thread |
| * @return M4NO_ERROR: there is no error |
| * @return M4ERR_PARAMETER: at least one parameter is NULL |
| * @return M4ERR_STATE: this function cannot be called now |
| * @return M4ERR_BAD_CONTEXT: provided context is not a valid one |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4OSA_threadSyncClose(M4OSA_Context context) |
| { |
| M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context; |
| M4OSA_ERR err_code; |
| |
| M4OSA_TRACE1_1("M4OSA_threadSyncClose\t\tM4OSA_Context 0x%x", context); |
| |
| M4OSA_DEBUG_IF2(context == M4OSA_NULL, |
| M4ERR_PARAMETER, "M4OSA_threadSyncClose"); |
| |
| M4OSA_DEBUG_IF2(threadContext->coreID != M4OSA_THREAD, |
| M4ERR_BAD_CONTEXT, "M4OSA_threadSyncClose"); |
| |
| M4OSA_DEBUG_IF2(threadContext->state == M4OSA_kThreadClosed, |
| M4ERR_BAD_CONTEXT, "M4OSA_threadSyncClose"); |
| |
| M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER); |
| |
| if(threadContext->state != M4OSA_kThreadOpened) |
| { |
| M4OSA_mutexUnlock(threadContext->stateMutex); |
| |
| M4OSA_DEBUG(M4ERR_STATE, "M4OSA_threadSyncClose"); |
| |
| return M4ERR_STATE; |
| } |
| |
| threadContext->state = M4OSA_kThreadClosed; |
| |
| M4OSA_mutexUnlock(threadContext->stateMutex); |
| |
| err_code = M4OSA_mutexClose(threadContext->stateMutex); |
| |
| if(M4OSA_ERR_IS_ERROR(err_code)) |
| { |
| M4OSA_DEBUG(err_code, "M4OSA_threadSyncClose: M4OSA_mutexClose"); |
| |
| return err_code; |
| } |
| |
| err_code = M4OSA_semaphoreClose(threadContext->semStartStop); |
| |
| if(M4OSA_ERR_IS_ERROR(err_code)) |
| { |
| M4OSA_DEBUG(err_code, "M4OSA_threadSyncClose: M4OSA_semaphoreClose"); |
| |
| return err_code; |
| } |
| |
| if(threadContext->name != M4OSA_NULL) |
| { |
| free(threadContext->name); |
| } |
| |
| free(threadContext); |
| |
| return M4NO_ERROR; |
| } |
| |
| |
| |
| |
| /** |
| ************************************************************************ |
| * @brief This method asks the thread to return its state. |
| * @note The caller is responsible for allocating/deallocating the state |
| * field. |
| * @param context:(IN) Context of the thread |
| * @param state:(OUT) Thread state |
| * @return M4NO_ERROR: there is no error |
| * @return M4ERR_PARAMETER: at least one parameter is NULL |
| * @return M4ERR_BAD_CONTEXT: provided context is not a valid one |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4OSA_threadSyncGetState(M4OSA_Context context, |
| M4OSA_ThreadState* state) |
| { |
| M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context; |
| |
| M4OSA_TRACE1_2("M4OSA_threadSyncGetState\t\tM4OSA_Context 0x%x\t" |
| "M4OSA_ThreadState* 0x%x", context, state); |
| |
| M4OSA_DEBUG_IF2(context == M4OSA_NULL, |
| M4ERR_PARAMETER, "M4OSA_threadSyncGetState"); |
| |
| M4OSA_DEBUG_IF2(state == M4OSA_NULL, |
| M4ERR_PARAMETER, "M4OSA_threadSyncGetState"); |
| |
| M4OSA_DEBUG_IF2(threadContext->coreID != M4OSA_THREAD, |
| M4ERR_BAD_CONTEXT, "M4OSA_threadSyncGetState"); |
| |
| *state = threadContext->state; |
| |
| return M4NO_ERROR; |
| } |
| |
| |
| |
| |
| /** |
| ************************************************************************ |
| * @brief This method asks the calling thread to sleep during "timeSleep" |
| * milliseconds. |
| * @note This function does not have any context. |
| * @param time:(IN) Time to sleep in milliseconds |
| * @return M4NO_ERROR: there is no error |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4OSA_threadSleep(M4OSA_UInt32 time) |
| { |
| struct timespec rqtp = { 0, 0 }; |
| struct timespec rmtp = { 0, 0 }; |
| |
| M4OSA_TRACE1_1("M4OSA_threadSleep\t\tM4OSA_UInt32 %d", time); |
| |
| rqtp.tv_sec = (time_t)time/1000; |
| rqtp.tv_nsec = (time%1000) * 1000000; |
| nanosleep(&rqtp, &rmtp); |
| |
| return M4NO_ERROR; |
| } |
| |
| #if(M4OSA_OPTIONID_THREAD_PRIORITY == M4OSA_TRUE) |
| |
| M4OSA_ERR M4OSA_SetThreadSyncPriority(M4OSA_Context context, |
| M4OSA_DataOption optionValue) |
| { |
| M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context; |
| M4OSA_ThreadPriorityLevel priority |
| = (M4OSA_ThreadPriorityLevel)(optionValue); |
| |
| M4OSA_TRACE2_2("M4OSA_SetThreadSyncPriority\t\tM4OSA_Context 0x%x\t" |
| "M4OSA_DataOption 0x%x", context, optionValue); |
| |
| if((M4OSA_UInt32)optionValue>M4OSA_kThreadLowestPriority) |
| { |
| return M4ERR_PARAMETER; |
| } |
| |
| threadContext->priority = priority; |
| |
| return M4NO_ERROR; |
| } |
| |
| #endif /*M4OSA_OPTIONID_THREAD_PRIORITY*/ |
| |
| |
| |
| |
| #if(M4OSA_OPTIONID_THREAD_NAME == M4OSA_TRUE) |
| |
| M4OSA_ERR M4OSA_SetThreadSyncName(M4OSA_Context context, |
| M4OSA_DataOption optionValue) |
| { |
| M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context; |
| M4OSA_Char* name = (M4OSA_Char*)optionValue; |
| M4OSA_UInt32 nameSize ; |
| |
| M4OSA_TRACE2_2("M4OSA_SetThreadSyncName\t\tM4OSA_Context 0x%x\t" |
| "M4OSA_DataOption 0x%x", context, optionValue); |
| |
| if(threadContext->name != NULL) |
| { |
| free(threadContext->name); |
| threadContext->name = M4OSA_NULL; |
| } |
| |
| if(optionValue != M4OSA_NULL) |
| { |
| nameSize = strlen((const char *)name)+1; |
| |
| threadContext->name = |
| (M4OSA_Char*)M4OSA_32bitAlignedMalloc(nameSize, M4OSA_THREAD, |
| (M4OSA_Char*)"M4OSA_SetThreadSyncName: thread name"); |
| |
| if(threadContext == M4OSA_NULL) |
| { |
| return M4ERR_ALLOC; |
| } |
| |
| memcpy((void *)threadContext->name, (void *)name, |
| nameSize); |
| } |
| |
| return M4NO_ERROR; |
| } |
| |
| #endif /*M4OSA_OPTIONID_THREAD_NAME*/ |
| |
| |
| #if(M4OSA_OPTIONID_THREAD_STACK_SIZE == M4OSA_TRUE) |
| |
| M4OSA_ERR M4OSA_SetThreadSyncStackSize(M4OSA_Context context, |
| M4OSA_DataOption optionValue) |
| { |
| M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context; |
| |
| M4OSA_TRACE2_2("M4OSA_SetThreadSyncStackSize\t\tM4OSA_Context 0x%x\t" |
| "M4OSA_DataOption 0x%x", context, optionValue); |
| |
| threadContext->stackSize = (M4OSA_UInt32)optionValue; |
| |
| return M4NO_ERROR; |
| } |
| |
| #endif /*M4OSA_OPTIONID_THREAD_STACK_SIZE*/ |
| |
| /** |
| ************************************************************************ |
| * @brief This method asks the core OSAL-Thread component to set the value |
| * associated with the optionID. The caller is responsible for |
| * allocating/deallocating the memory of the value field. |
| * @note As the caller is responsible of allocating/de-allocating the |
| * "value" field, the callee must copy this field to its internal |
| * variable. |
| * @param context:(IN/OUT) Context of the thread |
| * @param optionID:(IN) ID of the option |
| * @param optionValue:(IN) Value of the option |
| * @return M4NO_ERROR: there is no error |
| * @return M4ERR_PARAMETER: at least one parameter is NULL |
| * @return M4ERR_BAD_CONTEXT: provided context is not a valid one |
| * @return M4ERR_BAD_OPTION_ID: the optionID is not a valid one |
| * @return M4ERR_STATE: this option is not available now |
| * @return M4ERR_READ_ONLY: this option is a read only one |
| * @return M4ERR_NOT_IMPLEMENTED: this option is not implemented |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4OSA_threadSyncSetOption(M4OSA_Context context, |
| M4OSA_ThreadOptionID optionID, |
| M4OSA_DataOption optionValue) |
| { |
| M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context; |
| M4OSA_ERR err_code; |
| |
| M4OSA_TRACE1_3("M4OSA_threadSyncSetOption\t\tM4OSA_Context 0x%x\t" |
| "M4OSA_OptionID %d\tM4OSA_DataOption 0x%x", |
| context, optionID, optionValue); |
| |
| M4OSA_DEBUG_IF2(context == M4OSA_NULL, |
| M4ERR_PARAMETER, "M4OSA_threadSyncSetOption"); |
| |
| M4OSA_DEBUG_IF2(optionID == M4OSA_NULL, |
| M4ERR_PARAMETER, "M4OSA_threadSyncSetOption"); |
| |
| M4OSA_DEBUG_IF2(threadContext->coreID != M4OSA_THREAD, |
| M4ERR_BAD_CONTEXT, "M4OSA_threadSyncSetOption"); |
| |
| M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_COREID(optionID, M4OSA_THREAD), |
| M4ERR_BAD_OPTION_ID, "M4OSA_threadSyncSetOption"); |
| |
| M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_WRITABLE(optionID), |
| M4ERR_READ_ONLY, "M4OSA_threadSyncSetOption"); |
| |
| |
| M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER); |
| |
| if(threadContext->state != M4OSA_kThreadOpened) |
| { |
| M4OSA_mutexUnlock(threadContext->stateMutex); |
| |
| M4OSA_DEBUG(M4ERR_STATE, "M4OSA_threadSyncSetOption"); |
| |
| return M4ERR_STATE; |
| } |
| |
| switch(optionID) |
| { |
| |
| #if(M4OSA_OPTIONID_THREAD_PRIORITY == M4OSA_TRUE) |
| case M4OSA_ThreadPriority: |
| { |
| err_code = M4OSA_SetThreadSyncPriority(context, optionValue); |
| |
| break; |
| } |
| #endif /*M4OSA_OPTIONID_THREAD_PRIORITY*/ |
| |
| #if(M4OSA_OPTIONID_THREAD_NAME == M4OSA_TRUE) |
| case M4OSA_ThreadName: |
| { |
| err_code = M4OSA_SetThreadSyncName(context, optionValue); |
| |
| break; |
| } |
| #endif /*M4OSA_OPTIONID_THREAD_NAME*/ |
| |
| #if(M4OSA_OPTIONID_THREAD_STACK_SIZE == M4OSA_TRUE) |
| case M4OSA_ThreadStackSize: |
| { |
| err_code = M4OSA_SetThreadSyncStackSize(context, optionValue); |
| |
| break; |
| } |
| #endif /*M4OSA_OPTIONID_THREAD_STACK_SIZE*/ |
| |
| default: |
| { |
| M4OSA_DEBUG(M4ERR_NOT_IMPLEMENTED, "M4OSA_threadSyncSetOption"); |
| |
| err_code = M4ERR_NOT_IMPLEMENTED; |
| } |
| } |
| |
| M4OSA_mutexUnlock(threadContext->stateMutex); |
| |
| return err_code; |
| } |
| |
| |
| |
| /** |
| ************************************************************************ |
| * @brief This method asks the OSAL-Thread to return the value associated |
| * with the optionID. The caller is responsible for |
| * allocating/deallocating the memory of the value field. |
| * @note "optionValue" must be cast according to the type related to the |
| * optionID. |
| * @note As the caller is responsible for de-allocating the "value" |
| * field, the core OSAL-Thread component must perform a copy of its |
| * internal value to the value field. |
| * @param context:(IN) Context of the thread |
| * @param optionID:(IN) ID of the option |
| * @param optionValue:(OUT) Value of the option |
| * @return M4NO_ERROR: there is no error |
| * @return M4ERR_PARAMETER: at least one parameter is NULL |
| * @return M4ERR_BAD_CONTEXT: provided context is not a valid one |
| * @return M4ERR_BAD_OPTION_ID: the optionID is not a valid one |
| * @return M4ERR_WRITE_ONLY: this option is a write only one |
| * @return M4ERR_NOT_IMPLEMENTED: this option is not implemented |
| ************************************************************************ |
| */ |
| M4OSA_ERR M4OSA_threadSyncGetOption(M4OSA_Context context, |
| M4OSA_ThreadOptionID optionID, |
| M4OSA_DataOption* optionValue) |
| { |
| M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context; |
| |
| M4OSA_TRACE1_3("M4OSA_threadSyncGetOption\t\tM4OSA_Context 0x%x\t" |
| "M4OSA_OptionID %d\tM4OSA_DataOption* 0x%x", |
| context, optionID, optionValue); |
| |
| M4OSA_DEBUG_IF2(context == M4OSA_NULL, |
| M4ERR_PARAMETER, "M4OSA_threadSyncGetOption"); |
| |
| M4OSA_DEBUG_IF2(optionID == M4OSA_NULL, |
| M4ERR_PARAMETER, "M4OSA_threadSyncGetOption"); |
| |
| M4OSA_DEBUG_IF2(optionValue == M4OSA_NULL, |
| M4ERR_PARAMETER, "M4OSA_threadSyncGetOption"); |
| |
| M4OSA_DEBUG_IF2(threadContext->coreID != M4OSA_THREAD, |
| M4ERR_BAD_CONTEXT, "M4OSA_threadSyncGetOption"); |
| |
| M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_COREID(optionID, M4OSA_THREAD), |
| M4ERR_BAD_OPTION_ID, "M4OSA_threadSyncGetOption"); |
| |
| M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_READABLE(optionID), |
| M4ERR_WRITE_ONLY, "M4OSA_threadSyncGetOption"); |
| |
| switch(optionID) |
| { |
| |
| #if(M4OSA_OPTIONID_THREAD_PRIORITY == M4OSA_TRUE) |
| case M4OSA_ThreadPriority: |
| { |
| M4OSA_ThreadPriorityLevel* priority = |
| (M4OSA_ThreadPriorityLevel*)optionValue; |
| |
| *priority = threadContext->priority; |
| |
| return M4NO_ERROR; |
| } |
| #endif /*M4OSA_OPTIONID_THREAD_PRIORITY*/ |
| |
| #if(M4OSA_OPTIONID_THREAD_NAME == M4OSA_TRUE) |
| case M4OSA_ThreadName: |
| { |
| M4OSA_Char** name = (M4OSA_Char**)optionValue; |
| |
| *name = threadContext->name; |
| |
| return M4NO_ERROR; |
| } |
| #endif /*M4OSA_OPTIONID_THREAD_NAME*/ |
| |
| #if(M4OSA_OPTIONID_THREAD_STACK_SIZE == M4OSA_TRUE) |
| case M4OSA_ThreadStackSize: |
| { |
| M4OSA_UInt32* stackSize = (M4OSA_UInt32*)optionValue; |
| |
| *stackSize = threadContext->stackSize; |
| |
| return M4NO_ERROR; |
| } |
| #endif /*M4OSA_OPTIONID_THREAD_STACK_SIZE*/ |
| |
| default: |
| break; |
| } |
| |
| M4OSA_DEBUG(M4ERR_NOT_IMPLEMENTED, "M4OSA_threadSyncGetOption"); |
| |
| return M4ERR_NOT_IMPLEMENTED; |
| } |
| |
