1 /* 2 * 3 * Copyright 2010 Samsung Electronics S.LSI Co. LTD 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 /* 19 * @file SEC_OSAL_Thread.c 20 * @brief 21 * @author SeungBeom Kim (sbcrux.kim (at) samsung.com) 22 * @version 1.0 23 * @history 24 * 2010.7.15 : Create 25 */ 26 27 #include <stdio.h> 28 #include <stdlib.h> 29 #include <string.h> 30 #include <pthread.h> 31 #include <semaphore.h> 32 #include <errno.h> 33 34 #include "SEC_OSAL_Memory.h" 35 #include "SEC_OSAL_Thread.h" 36 37 #undef SEC_LOG_TAG 38 #define SEC_LOG_TAG "SEC_LOG_THREAD" 39 #define SEC_LOG_OFF 40 #include "SEC_OSAL_Log.h" 41 42 43 typedef struct _SEC_THREAD_HANDLE_TYPE 44 { 45 pthread_t pthread; 46 pthread_attr_t attr; 47 struct sched_param schedparam; 48 int stack_size; 49 } SEC_THREAD_HANDLE_TYPE; 50 51 52 OMX_ERRORTYPE SEC_OSAL_ThreadCreate(OMX_HANDLETYPE *threadHandle, OMX_PTR function_name, OMX_PTR argument) 53 { 54 FunctionIn(); 55 56 int result = 0; 57 int detach_ret = 0; 58 SEC_THREAD_HANDLE_TYPE *thread; 59 OMX_ERRORTYPE ret = OMX_ErrorNone; 60 61 thread = SEC_OSAL_Malloc(sizeof(SEC_THREAD_HANDLE_TYPE)); 62 SEC_OSAL_Memset(thread, 0, sizeof(SEC_THREAD_HANDLE_TYPE)); 63 64 pthread_attr_init(&thread->attr); 65 if (thread->stack_size != 0) 66 pthread_attr_setstacksize(&thread->attr, thread->stack_size); 67 68 /* set priority */ 69 if (thread->schedparam.sched_priority != 0) 70 pthread_attr_setschedparam(&thread->attr, &thread->schedparam); 71 72 detach_ret = pthread_attr_setdetachstate(&thread->attr, PTHREAD_CREATE_JOINABLE); 73 if (detach_ret != 0) { 74 ret = OMX_ErrorUndefined; 75 goto EXIT; 76 } 77 78 result = pthread_create(&thread->pthread, &thread->attr, function_name, (void *)argument); 79 /* pthread_setschedparam(thread->pthread, SCHED_RR, &thread->schedparam); */ 80 81 switch (result) { 82 case 0: 83 *threadHandle = (OMX_HANDLETYPE)thread; 84 ret = OMX_ErrorNone; 85 break; 86 case EAGAIN: 87 *threadHandle = NULL; 88 ret = OMX_ErrorInsufficientResources; 89 break; 90 default: 91 *threadHandle = NULL; 92 ret = OMX_ErrorUndefined; 93 break; 94 } 95 96 EXIT: 97 FunctionOut(); 98 99 return ret; 100 } 101 102 OMX_ERRORTYPE SEC_OSAL_ThreadTerminate(OMX_HANDLETYPE threadHandle) 103 { 104 FunctionIn(); 105 106 OMX_ERRORTYPE ret = OMX_ErrorNone; 107 SEC_THREAD_HANDLE_TYPE *thread = (SEC_THREAD_HANDLE_TYPE *)threadHandle; 108 109 if (!thread) { 110 ret = OMX_ErrorBadParameter; 111 goto EXIT; 112 } 113 if (pthread_join(thread->pthread, NULL) != 0) { 114 ret = OMX_ErrorUndefined; 115 goto EXIT; 116 } 117 118 SEC_OSAL_Free(thread); 119 ret = OMX_ErrorNone; 120 121 EXIT: 122 FunctionOut(); 123 124 return ret; 125 126 } 127 128 OMX_ERRORTYPE SEC_OSAL_ThreadCancle(OMX_HANDLETYPE threadHandle) 129 { 130 SEC_THREAD_HANDLE_TYPE *thread = (SEC_THREAD_HANDLE_TYPE *)threadHandle; 131 132 if (!thread) 133 return OMX_ErrorBadParameter; 134 135 /* thread_cancel(thread->pthread); */ 136 pthread_exit(thread->pthread); 137 pthread_join(thread->pthread, NULL); 138 139 SEC_OSAL_Free(thread); 140 return OMX_ErrorNone; 141 } 142 143 void SEC_OSAL_TheadExit(void *value_ptr) 144 { 145 pthread_exit(value_ptr); 146 return; 147 } 148 149 void SEC_OSAL_SleepMillisec(OMX_U32 ms) 150 { 151 usleep(ms * 1000); 152 return; 153 } 154