1 /******************************************************************************* 2 **+--------------------------------------------------------------------------+** 3 **| |** 4 **| Copyright 1998-2008 Texas Instruments, Inc. - http://www.ti.com/ |** 5 **| |** 6 **| Licensed under the Apache License, Version 2.0 (the "License"); |** 7 **| you may not use this file except in compliance with the License. |** 8 **| You may obtain a copy of the License at |** 9 **| |** 10 **| http://www.apache.org/licenses/LICENSE-2.0 |** 11 **| |** 12 **| Unless required by applicable law or agreed to in writing, software |** 13 **| distributed under the License is distributed on an "AS IS" BASIS, |** 14 **| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |** 15 **| See the License for the specific language governing permissions and |** 16 **| limitations under the License. |** 17 **| |** 18 **+--------------------------------------------------------------------------+** 19 *******************************************************************************/ 20 21 // TILibLinux.cpp : 22 // 23 #include <stdio.h> 24 #include <errno.h> 25 #include <time.h> 26 27 #include "CommonOAL.h" 28 #include "TILibLinux.h" 29 #include <pthread.h> 30 31 ////////////////////////////////////////////////////////////////////// 32 // CTI_LibLinux Class 33 ////////////////////////////////////////////////////////////////////// 34 TIOALib_SINGLETON_CLASS_IMP( CTI_LibLinux ) 35 TIOALib_OBJECT_CREATOR_IMP( CTI_OSCriticalSectionLinux, TI_OSWrapCriticalSection ) 36 37 ////////////////////////////////////////////////////////////////////// 38 // Construction/Destruction 39 ////////////////////////////////////////////////////////////////////// 40 41 CTI_LibLinux::CTI_LibLinux() 42 { 43 } 44 45 CTI_LibLinux::~CTI_LibLinux() 46 { 47 } 48 49 tiVOID 50 CTI_LibLinux::TIOutputDebugString (tiCHAR* lpOutputString) 51 { 52 if ( lpOutputString ) 53 fprintf(stderr, lpOutputString); 54 } 55 56 tiUINT32 57 CTI_LibLinux::TILoadLibrary(tiCHAR* lpLibFileName) 58 { 59 return 0; 60 } 61 tiUINT32 62 CTI_LibLinux::TIGetCurrentThreadId() 63 { 64 return pthread_self(); 65 } 66 67 tiBOOL 68 CTI_LibLinux::TIFreeLibrary( tiUINT32 hLibModule ) 69 { 70 return 0; 71 } 72 73 tiUINT32 74 CTI_LibLinux::TIRegisterWindowMessage (tiCHAR* lpszMsgName) 75 { 76 return 0; 77 } 78 79 tiBOOL 80 CTI_LibLinux::TIPostMessage(tiUINT32 hWnd, tiUINT32 uMsg, tiUINT32 wParam, tiUINT32 lParam) 81 { 82 return 0; 83 } 84 85 tiUINT32 86 CTI_LibLinux::TIGetProcAddress(tiUINT32 hModule, tiCHAR* lpProcName ) 87 { 88 return 0; 89 } 90 91 tiBOOL 92 CTI_LibLinux::TIIsBadWritePtr(tiVOID *lp, tiUINT32 ucb ) 93 { 94 return FALSE; //IsBadWritePtr(lp, ucb ); 95 } 96 97 tiVOID 98 CTI_LibLinux::TIPrintLastError(tiCHAR* lpsz) 99 { 100 #ifdef DEBUG_MESSAGES 101 tiCHAR szTmp[512]; 102 sprintf(szTmp,"%s LastError(0x%Xh)\n", lpsz, errno); 103 TIOutputDebugString(szTmp); 104 #endif 105 } 106 107 108 tiUINT32 109 CTI_LibLinux::TICreateThread(tiPTHREAD_START_ROUTINE pStartAddress, tiVOID* pParameter ) 110 { 111 uxTHREAD_START_ROUTINE thread_start_address = (uxTHREAD_START_ROUTINE)pStartAddress; 112 pthread_t supp_thread_id; 113 pthread_attr_t supp_thread_attrs; 114 115 pthread_attr_init(&supp_thread_attrs); 116 117 int iRet = pthread_create(&supp_thread_id, &supp_thread_attrs, thread_start_address, pParameter); 118 119 pthread_attr_destroy(&supp_thread_attrs); 120 121 if ( iRet == 0) 122 return TI_RESULT_OK; 123 124 return TI_RESULT_FAILED; 125 } 126 127 128 CTI_OSCriticalSectionLinux::CTI_OSCriticalSectionLinux() 129 { 130 /* m_pCS = (tiVOID*) new pthread_rwlock_t; 131 132 if ( m_pCS ) 133 { 134 memset( m_pCS, 0, sizeof(pthread_rwlock_t)); 135 pthread_rwlock_init((pthread_rwlock_t*) m_pCS, NULL ) 136 } 137 */ 138 } 139 140 CTI_OSCriticalSectionLinux::~CTI_OSCriticalSectionLinux() 141 { 142 /* 143 if (m_pCS) 144 { 145 pthread_rwlock_destroy((pthread_rwlock_t*) m_pCS); 146 delete m_pCS; 147 m_pCS = NULL; 148 } 149 */ 150 } 151 152 tiVOID 153 CTI_OSCriticalSectionLinux::Enter() 154 { 155 /* 156 if ( m_pCS ) 157 pthread_rwlock_wrlock((pthread_rwlock_t*) m_pCS); 158 */ 159 } 160 161 tiVOID 162 CTI_OSCriticalSectionLinux::Leave() 163 { 164 /* 165 if ( m_pCS ) 166 pthread_rwlock_unlock((pthread_rwlock_t*) m_pCS); 167 */ 168 } 169 170 tiVOID 171 CTI_LibLinux::TISleep(tiUINT32 msec) 172 { 173 struct timespec req; 174 175 req.tv_sec = 0; 176 req.tv_nsec = 100000; /* sleep for 100 msec */ 177 nanosleep( &req, NULL ); 178 } 179 180 /* 181 182 CTI_OSEventLinux::CTI_OSEventLinux() 183 { 184 m_bSet = FALSE; 185 186 pthread_condattr_init(&m_CondAttr); 187 pthread_cond_init(&m_Cond, &m_CondAttr); 188 189 pthread_mutexattr_init(&m_MutexAttr); 190 pthread_mutexattr_settype(&m_MutexAttr, PTHREAD_MUTEX_NORMAL); 191 192 m_pEvent = (tiVOID*) new pthread_mutex_t; 193 194 if ( m_pEvent ) 195 { 196 memset( m_pEvent, 0, sizeof(pthread_mutex_t)); 197 pthread_mutex_init( (pthread_mutex_t*) m_pEvent, &m_MutexAttr); 198 } 199 } 200 201 CTI_OSEventLinux::~CTI_OSEventLinux() 202 { 203 if (m_pEvent) 204 { 205 pthread_mutex_destroy((pthread_mutex_t*) m_pEvent); 206 delete m_pEvent; 207 m_pEvent = NULL; 208 } 209 210 pthread_mutexattr_destroy(&m_attr); 211 pthread_cond_destroy(&m_Cond); 212 pthread_condattr_destroy(&m_CondAttr); 213 } 214 215 tiVOID 216 CTI_OSEventLinux::Set() 217 { 218 if ( m_pEvent ) 219 pthread_cond_signal((pthread_mutex_t*) m_pEvent); 220 } 221 222 tiUINT32 223 CTI_OSEventLinux::Wait(tiUINT32 uTimeout) 224 { 225 if (m_pEvent) 226 { 227 pthread_mutex_lock((pthread_mutex_t*) m_pEvent); 228 229 if (uTimeout == INFINITE) 230 { 231 while (!m_bSet) // have to wait for the event 232 pthread_cond_wait(&m_Cond, (pthread_mutex_t*) m_pEvent ); 233 } 234 else 235 { 236 timespec timeOut; 237 clock_gettime(CLOCK_REALTIME, &timeOut); 238 239 // if there are seconds involved 240 if (uTimeout >= 1000) 241 { 242 timeOut.tv_sec += uTimeout / 1000; 243 244 // get rest 245 int nRemain = nMilliseconds % 1000; 246 if (nRemain != 0) 247 { 248 timeOut.tv_nsec += nRemain * 1000000L; 249 250 // wrapped into the next second 251 if (timeOut.tv_nsec > 1000000000L) 252 { 253 timeOut.tv_nsec -= 1000000000L; 254 timeOut.tv_sec++; 255 } 256 } 257 } 258 else 259 { 260 timeOut.tv_nsec += uTimeout * 1000000L; 261 } 262 263 while (!m_bSet) // have to wait for the event 264 { 265 // the following line releases the mutex and waits until the 266 // condition is signalled. when the call returns, we own the 267 // mutex again, unless an exception is thrown, in which case 268 // the mutex is unlocked 269 270 int nResult = pthread_cond_timedwait(&m_Cond, (pthread_mutex_t*) m_pEvent , &timeOut)); 271 272 if ( nResult != 0 ) 273 { 274 pthread_mutex_unlock((pthread_mutex_t*) m_pEvent); 275 // time out, we have the lock 276 pthread_mutex_lock((pthread_mutex_t*) m_pEvent); 277 278 // return "time out" condition 279 return; 280 } 281 282 } 283 }; 284 285 inline _dcfTimeOut::_dcfTimeOut(unsigned int nMilliseconds) 286 { 287 int nResult = clock_gettime(CLOCK_REALTIME, &_tsWhen); 288 289 #ifdef _DEBUG 290 DCF_ASSERT(nResult == 0); 291 #endif 292 293 294 } 295 } 296 return TI_RESULT_OK; 297 } 298 */ 299 300