00001
00002
00003
00004
00005 #include "ace/OS_NS_macros.h"
00006
00007 #include "ace/Time_Value.h"
00008 #include "ace/OS_NS_sys_mman.h"
00009 #include "ace/OS_NS_sys_time.h"
00010 #include "ace/OS_NS_string.h"
00011 #include "ace/OS_NS_unistd.h"
00012 #include "ace/OS_NS_stdio.h"
00013 #include "ace/OS_NS_errno.h"
00014
00015 #if defined (ACE_USES_FIFO_SEM)
00016 # include "ace/OS_NS_sys_stat.h"
00017 # include "ace/OS_NS_sys_select.h"
00018 # include "ace/OS_NS_fcntl.h"
00019 # include "ace/Handle_Set.h"
00020 # endif
00021
00022 #if defined (ACE_HAS_PRIOCNTL)
00023 # include <sys/priocntl.h>
00024 #endif
00025
00026 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00027
00028
00029
00030 #if defined (ACE_LACKS_COND_T) && defined (ACE_HAS_THREADS)
00031 ACE_INLINE long
00032 ACE_cond_t::waiters (void) const
00033 {
00034 return this->waiters_;
00035 }
00036 #endif
00037
00038
00039
00040 #if defined (ACE_HAS_TSS_EMULATION)
00041
00042 # if !defined (ACE_HAS_THREAD_SPECIFIC_STORAGE)
00043 ACE_INLINE
00044 void **&
00045 ACE_TSS_Emulation::tss_base ()
00046 {
00047 # if defined (ACE_HAS_VXTHREADS)
00048 int &spare = taskIdCurrent->ACE_VXWORKS_SPARE;
00049 return reinterpret_cast <void **&> (spare);
00050 # else
00051
00052 ACE_NOTSUP_RETURN (0);
00053 # endif
00054 }
00055 # endif
00056
00057 ACE_INLINE
00058 ACE_TSS_Emulation::ACE_TSS_DESTRUCTOR
00059 ACE_TSS_Emulation::tss_destructor (const ACE_thread_key_t key)
00060 {
00061 ACE_KEY_INDEX (key_index, key);
00062 return tss_destructor_ [key_index];
00063 }
00064
00065 ACE_INLINE
00066 void
00067 ACE_TSS_Emulation::tss_destructor (const ACE_thread_key_t key,
00068 ACE_TSS_DESTRUCTOR destructor)
00069 {
00070 ACE_KEY_INDEX (key_index, key);
00071 tss_destructor_ [key_index] = destructor;
00072 }
00073
00074 ACE_INLINE
00075 void *&
00076 ACE_TSS_Emulation::ts_object (const ACE_thread_key_t key)
00077 {
00078 ACE_KEY_INDEX (key_index, key);
00079
00080 # if defined (ACE_HAS_VXTHREADS)
00081
00082
00083
00084 if (0 == taskIdCurrent->ACE_VXWORKS_SPARE)
00085 {
00086 taskIdCurrent->ACE_VXWORKS_SPARE =
00087 reinterpret_cast<int> (new void *[ACE_TSS_THREAD_KEYS_MAX]);
00088
00089
00090
00091 void **tss_base_p =
00092 reinterpret_cast<void **> (taskIdCurrent->ACE_VXWORKS_SPARE);
00093 for (u_int i = 0; i < ACE_TSS_THREAD_KEYS_MAX; ++i, ++tss_base_p)
00094 {
00095 *tss_base_p = 0;
00096 }
00097 }
00098 # endif
00099
00100 return tss_base ()[key_index];
00101 }
00102
00103 #endif
00104
00105
00106
00107 ACE_INLINE int
00108 ACE_OS::thr_equal (ACE_thread_t t1, ACE_thread_t t2)
00109 {
00110 #if defined (ACE_HAS_PTHREADS)
00111 # if defined (pthread_equal)
00112
00113 return pthread_equal (t1, t2);
00114 # else
00115 return pthread_equal (t1, t2);
00116 # endif
00117 #else
00118
00119
00120 return t1 == t2;
00121 #endif
00122 }
00123
00124 ACE_INLINE int
00125 ACE_OS::condattr_destroy (ACE_condattr_t &attributes)
00126 {
00127 #if defined (ACE_HAS_THREADS)
00128 # if defined (ACE_HAS_PTHREADS)
00129 pthread_condattr_destroy (&attributes);
00130 # else
00131 attributes.type = 0;
00132 # endif
00133 return 0;
00134 # else
00135 ACE_UNUSED_ARG (attributes);
00136 return 0;
00137 # endif
00138 }
00139
00140 ACE_INLINE int
00141 ACE_OS::condattr_init (ACE_condattr_t &attributes, int type)
00142 {
00143 ACE_UNUSED_ARG (type);
00144 # if defined (ACE_HAS_THREADS)
00145 # if defined (ACE_HAS_PTHREADS)
00146 int result = -1;
00147
00148 # if defined (ACE_PTHREAD_CONDATTR_T_INITIALIZE)
00149
00150
00151
00152
00153 ACE_OS::memset (&attributes, 0, sizeof (attributes));
00154 # endif
00155 if (
00156 ACE_ADAPT_RETVAL (pthread_condattr_init (&attributes), result) == 0
00157 # if defined (_POSIX_THREAD_PROCESS_SHARED) && !defined (ACE_LACKS_CONDATTR_PSHARED)
00158 && ACE_ADAPT_RETVAL (pthread_condattr_setpshared (&attributes, type),
00159 result) == 0
00160 # endif
00161 )
00162 result = 0;
00163 else
00164 result = -1;
00165
00166 return result;
00167 # else
00168 attributes.type = type;
00169 return 0;
00170 # endif
00171
00172 # else
00173 ACE_UNUSED_ARG (attributes);
00174 ACE_UNUSED_ARG (type);
00175 ACE_NOTSUP_RETURN (-1);
00176 # endif
00177 }
00178
00179 #if !defined (ACE_LACKS_COND_T)
00180
00181
00182
00183
00184
00185 ACE_INLINE int
00186 ACE_OS::cond_broadcast (ACE_cond_t *cv)
00187 {
00188 ACE_OS_TRACE ("ACE_OS::cond_broadcast");
00189 # if defined (ACE_HAS_THREADS)
00190 # if defined (ACE_HAS_PTHREADS)
00191 int result;
00192 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_cond_broadcast (cv),
00193 result),
00194 int, -1);
00195 # elif defined (ACE_HAS_STHREADS)
00196 int result;
00197 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cond_broadcast (cv),
00198 result),
00199 int, -1);
00200 # elif defined (ACE_HAS_WTHREADS) && defined (ACE_HAS_WTHREADS_CONDITION_VARIABLE)
00201 ::WakeAllConditionVariable (cv);
00202 return 0;
00203 # endif
00204 # else
00205 ACE_UNUSED_ARG (cv);
00206 ACE_NOTSUP_RETURN (-1);
00207 # endif
00208 }
00209
00210 ACE_INLINE int
00211 ACE_OS::cond_destroy (ACE_cond_t *cv)
00212 {
00213 ACE_OS_TRACE ("ACE_OS::cond_destroy");
00214 # if defined (ACE_HAS_THREADS)
00215 # if defined (ACE_HAS_PTHREADS)
00216 int result;
00217 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_cond_destroy (cv), result), int, -1);
00218 # elif defined (ACE_HAS_STHREADS)
00219 int result;
00220 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cond_destroy (cv), result), int, -1);
00221 # elif defined (ACE_HAS_WTHREADS) && defined (ACE_HAS_WTHREADS_CONDITION_VARIABLE)
00222
00223 return 0;
00224 # endif
00225 # else
00226 ACE_UNUSED_ARG (cv);
00227 ACE_NOTSUP_RETURN (-1);
00228 # endif
00229 }
00230
00231 ACE_INLINE int
00232 ACE_OS::cond_init (ACE_cond_t *cv,
00233 ACE_condattr_t &attributes,
00234 const char *name,
00235 void *arg)
00236 {
00237
00238 ACE_UNUSED_ARG (name);
00239 ACE_UNUSED_ARG (arg);
00240 # if defined (ACE_HAS_THREADS)
00241 # if defined (ACE_HAS_PTHREADS)
00242 int result = -1;
00243
00244 # if defined (ACE_PTHREAD_COND_T_INITIALIZE)
00245
00246
00247
00248
00249
00250
00251 ACE_OS::memset (cv, 0, sizeof (*cv));
00252 # endif
00253
00254 if (ACE_ADAPT_RETVAL (pthread_cond_init (cv, &attributes), result) == 0)
00255 result = 0;
00256 else
00257 result = -1;
00258
00259 return result;
00260 # elif defined (ACE_HAS_STHREADS)
00261 int result;
00262 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cond_init (cv,
00263 attributes.type,
00264 arg),
00265 result),
00266 int, -1);
00267 # elif defined (ACE_HAS_WTHREADS) && defined (ACE_HAS_WTHREADS_CONDITION_VARIABLE)
00268 ::InitializeConditionVariable (cv);
00269 return 0;
00270 # endif
00271 # else
00272 ACE_UNUSED_ARG (cv);
00273 ACE_UNUSED_ARG (attributes);
00274 ACE_UNUSED_ARG (name);
00275 ACE_UNUSED_ARG (arg);
00276 ACE_NOTSUP_RETURN (-1);
00277 # endif
00278 }
00279
00280 #if defined (ACE_HAS_WCHAR)
00281 ACE_INLINE int
00282 ACE_OS::cond_init (ACE_cond_t *cv,
00283 ACE_condattr_t &attributes,
00284 const wchar_t *name,
00285 void *arg)
00286 {
00287 return ACE_OS::cond_init (cv, attributes, ACE_Wide_To_Ascii (name).char_rep (), arg);
00288 }
00289 #endif
00290
00291 #if defined (ACE_HAS_WCHAR)
00292 ACE_INLINE int
00293 ACE_OS::cond_init (ACE_cond_t *cv, short type, const wchar_t *name, void *arg)
00294 {
00295 return ACE_OS::cond_init (cv, type, ACE_Wide_To_Ascii (name).char_rep (), arg);
00296 }
00297 #endif
00298
00299 ACE_INLINE int
00300 ACE_OS::cond_signal (ACE_cond_t *cv)
00301 {
00302 ACE_OS_TRACE ("ACE_OS::cond_signal");
00303 # if defined (ACE_HAS_THREADS)
00304 # if defined (ACE_HAS_PTHREADS)
00305 int result;
00306 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_cond_signal (cv), result),
00307 int, -1);
00308 # elif defined (ACE_HAS_STHREADS)
00309 int result;
00310 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cond_signal (cv), result), int, -1);
00311 # elif defined (ACE_HAS_WTHREADS) && defined (ACE_HAS_WTHREADS_CONDITION_VARIABLE)
00312 ::WakeConditionVariable (cv);
00313 return 0;
00314 # endif
00315 # else
00316 ACE_UNUSED_ARG (cv);
00317 ACE_NOTSUP_RETURN (-1);
00318 # endif
00319 }
00320
00321 ACE_INLINE int
00322 ACE_OS::cond_wait (ACE_cond_t *cv,
00323 ACE_mutex_t *external_mutex)
00324 {
00325 ACE_OS_TRACE ("ACE_OS::cond_wait");
00326 # if defined (ACE_HAS_THREADS)
00327 # if defined (ACE_HAS_PTHREADS)
00328 int result;
00329 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_cond_wait (cv, external_mutex), result),
00330 int, -1);
00331 # elif defined (ACE_HAS_STHREADS)
00332 int result;
00333 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::cond_wait (cv, external_mutex), result),
00334 int, -1);
00335 # elif defined (ACE_HAS_WTHREADS) && defined (ACE_HAS_WTHREADS_CONDITION_VARIABLE)
00336 int result;
00337 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::SleepConditionVariableCS (cv, &external_mutex->thr_mutex_, INFINITE), result),
00338 int, -1);
00339 # endif
00340 # else
00341 ACE_UNUSED_ARG (cv);
00342 ACE_UNUSED_ARG (external_mutex);
00343 ACE_NOTSUP_RETURN (-1);
00344 # endif
00345 }
00346
00347 ACE_INLINE int
00348 ACE_OS::cond_timedwait (ACE_cond_t *cv,
00349 ACE_mutex_t *external_mutex,
00350 ACE_Time_Value *timeout)
00351 {
00352 ACE_OS_TRACE ("ACE_OS::cond_timedwait");
00353 # if defined (ACE_HAS_THREADS)
00354 int result = 0;
00355 timespec_t ts;
00356
00357 if (timeout != 0)
00358 ts = *timeout;
00359
00360 # if defined (ACE_HAS_PTHREADS)
00361
00362 ACE_OSCALL (ACE_ADAPT_RETVAL (timeout == 0
00363 ? pthread_cond_wait (cv, external_mutex)
00364 : pthread_cond_timedwait (cv, external_mutex,
00365 (ACE_TIMESPEC_PTR) &ts),
00366 result),
00367 int, -1, result);
00368
00369
00370 if (result == -1 &&
00371 (errno == ETIMEDOUT || errno == EAGAIN))
00372 errno = ETIME;
00373
00374 # elif defined (ACE_HAS_STHREADS)
00375 ACE_OSCALL (ACE_ADAPT_RETVAL (timeout == 0
00376 ? ::cond_wait (cv, external_mutex)
00377 : ::cond_timedwait (cv,
00378 external_mutex,
00379 (timestruc_t*)&ts),
00380 result),
00381 int, -1, result);
00382 # elif defined (ACE_HAS_WTHREADS) && defined (ACE_HAS_WTHREADS_CONDITION_VARIABLE)
00383 int msec_timeout = 0;
00384 if (timeout != 0)
00385 {
00386 ACE_Time_Value relative_time (*timeout - ACE_OS::gettimeofday ());
00387
00388
00389 if (relative_time > ACE_Time_Value::zero)
00390 msec_timeout = relative_time.msec ();
00391 }
00392
00393 ACE_OSCALL (ACE_ADAPT_RETVAL (::SleepConditionVariableCS (cv, &external_mutex->thr_mutex_, msec_timeout),
00394 result),
00395 int, -1, result);
00396
00397 return result;
00398 # endif
00399 if (timeout != 0)
00400 timeout->set (ts);
00401
00402 return result;
00403 # else
00404 ACE_UNUSED_ARG (cv);
00405 ACE_UNUSED_ARG (external_mutex);
00406 ACE_UNUSED_ARG (timeout);
00407 ACE_NOTSUP_RETURN (-1);
00408 # endif
00409 }
00410 #endif
00411
00412 ACE_INLINE int
00413 ACE_OS::mutex_lock (ACE_mutex_t *m,
00414 const ACE_Time_Value *timeout)
00415 {
00416 return timeout == 0 ? ACE_OS::mutex_lock (m) : ACE_OS::mutex_lock (m, *timeout);
00417 }
00418
00419 #if defined (ACE_HAS_WCHAR)
00420 ACE_INLINE int
00421 ACE_OS::event_init (ACE_event_t *event,
00422 int manual_reset,
00423 int initial_state,
00424 int type,
00425 const wchar_t *name,
00426 void *arg,
00427 LPSECURITY_ATTRIBUTES sa)
00428 {
00429 #if defined (ACE_WIN32)
00430 ACE_UNUSED_ARG (type);
00431 ACE_UNUSED_ARG (arg);
00432 SECURITY_ATTRIBUTES sa_buffer;
00433 SECURITY_DESCRIPTOR sd_buffer;
00434 *event = ::CreateEventW (ACE_OS::default_win32_security_attributes_r
00435 (sa, &sa_buffer, &sd_buffer),
00436 manual_reset,
00437 initial_state,
00438 name);
00439 if (*event == 0)
00440 ACE_FAIL_RETURN (-1);
00441
00442
00443 ACE_OS::set_errno_to_last_error ();
00444 return 0;
00445 #else
00446 return ACE_OS::event_init (event,
00447 manual_reset,
00448 initial_state,
00449 type,
00450 ACE_Wide_To_Ascii (name).char_rep (),
00451 arg,
00452 sa);
00453 #endif
00454 }
00455 #endif
00456
00457 ACE_INLINE long
00458 ACE_OS::priority_control (ACE_idtype_t idtype, ACE_id_t identifier, int cmd, void *arg)
00459 {
00460 ACE_OS_TRACE ("ACE_OS::priority_control");
00461 #if defined (ACE_HAS_PRIOCNTL)
00462 ACE_OSCALL_RETURN (priocntl (idtype, identifier, cmd, static_cast<caddr_t> (arg)),
00463 long, -1);
00464 #else
00465 ACE_UNUSED_ARG (idtype);
00466 ACE_UNUSED_ARG (identifier);
00467 ACE_UNUSED_ARG (cmd);
00468 ACE_UNUSED_ARG (arg);
00469 ACE_NOTSUP_RETURN (-1);
00470 #endif
00471 }
00472
00473
00474
00475
00476
00477
00478
00479 ACE_INLINE int
00480 ACE_OS::recursive_mutex_cond_unlock (ACE_recursive_thread_mutex_t *m,
00481 ACE_recursive_mutex_state &state)
00482 {
00483 #if defined (ACE_HAS_THREADS)
00484 ACE_OS_TRACE ("ACE_OS::recursive_mutex_cond_unlock");
00485 # if defined (ACE_HAS_RECURSIVE_MUTEXES)
00486
00487
00488 # if defined (ACE_WIN32)
00489
00490
00491
00492
00493
00494
00495
00496
00497
00498
00499 state.relock_count_ = 0;
00500 while (
00501 # if !defined (ACE_HAS_WINCE)
00502 m->LockCount > 0 && m->RecursionCount > 1
00503 # else
00504
00505
00506 m->LockCount > 1
00507 # endif
00508 )
00509 {
00510
00511
00512
00513 if (ACE_OS::recursive_mutex_unlock (m) == -1)
00514 return -1;
00515 ++state.relock_count_;
00516 }
00517 # else
00518
00519 ACE_UNUSED_ARG (state);
00520 ACE_UNUSED_ARG (m);
00521 # endif
00522 return 0;
00523 # else
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534 if (ACE_OS::thread_mutex_lock (&m->nesting_mutex_) == -1)
00535 return -1;
00536
00537 # if !defined (ACE_NDEBUG)
00538 if (m->nesting_level_ == 0
00539 || ACE_OS::thr_equal (ACE_OS::thr_self (), m->owner_id_) == 0)
00540 {
00541 ACE_OS::thread_mutex_unlock (&m->nesting_mutex_);
00542 errno = EINVAL;
00543 return -1;
00544 }
00545 # endif
00546
00547
00548
00549
00550 if (ACE_OS::cond_signal (&m->lock_available_) == -1)
00551 {
00552
00553 ACE_Errno_Guard error (errno);
00554 ACE_OS::thread_mutex_unlock (&m->nesting_mutex_);
00555 return -1;
00556 }
00557
00558
00559
00560
00561
00562 state.nesting_level_ = m->nesting_level_;
00563 state.owner_id_ = m->owner_id_;
00564 m->nesting_level_ = 0;
00565 m->owner_id_ = ACE_OS::NULL_thread;
00566 return 0;
00567 # endif
00568 #else
00569 ACE_UNUSED_ARG (m);
00570 ACE_UNUSED_ARG (state);
00571 ACE_NOTSUP_RETURN (-1);
00572 #endif
00573 }
00574
00575
00576
00577
00578
00579
00580 ACE_INLINE void
00581 ACE_OS::recursive_mutex_cond_relock (ACE_recursive_thread_mutex_t *m,
00582 ACE_recursive_mutex_state &state)
00583 {
00584 #if defined (ACE_HAS_THREADS)
00585 ACE_OS_TRACE ("ACE_OS::recursive_mutex_cond_relock");
00586 # if defined (ACE_HAS_RECURSIVE_MUTEXES)
00587
00588
00589
00590
00591
00592 # if defined (ACE_WIN32)
00593 while (state.relock_count_ > 0)
00594 {
00595 ACE_OS::recursive_mutex_lock (m);
00596 --state.relock_count_;
00597 }
00598 return;
00599 # else
00600
00601 ACE_UNUSED_ARG (state);
00602 ACE_UNUSED_ARG (m);
00603
00604 # endif
00605 # else
00606
00607
00608
00609
00610
00611
00612
00613 while (m->nesting_level_ > 0)
00614 ACE_OS::cond_wait (&m->lock_available_, &m->nesting_mutex_);
00615
00616
00617 m->nesting_level_ = state.nesting_level_;
00618 m->owner_id_ = state.owner_id_;
00619 ACE_OS::thread_mutex_unlock (&m->nesting_mutex_);
00620 return;
00621 # endif
00622 #else
00623 ACE_UNUSED_ARG (m);
00624 ACE_UNUSED_ARG (state);
00625 return;
00626 #endif
00627 }
00628
00629 ACE_INLINE int
00630 ACE_OS::recursive_mutex_destroy (ACE_recursive_thread_mutex_t *m)
00631 {
00632 #if defined (ACE_HAS_THREADS)
00633 #if defined (ACE_HAS_RECURSIVE_MUTEXES)
00634 return ACE_OS::thread_mutex_destroy (m);
00635 #else
00636 if (ACE_OS::thread_mutex_destroy (&m->nesting_mutex_) == -1)
00637 return -1;
00638 else if (ACE_OS::cond_destroy (&m->lock_available_) == -1)
00639 return -1;
00640 else
00641 return 0;
00642 #endif
00643 #else
00644 ACE_UNUSED_ARG (m);
00645 ACE_NOTSUP_RETURN (-1);
00646 #endif
00647 }
00648
00649 ACE_INLINE int
00650 ACE_OS::recursive_mutex_init (ACE_recursive_thread_mutex_t *m,
00651 const ACE_TCHAR *name,
00652 ACE_mutexattr_t *arg,
00653 LPSECURITY_ATTRIBUTES sa)
00654 {
00655 ACE_UNUSED_ARG (sa);
00656 #if defined (ACE_HAS_THREADS)
00657 # if defined (ACE_HAS_RECURSIVE_MUTEXES)
00658 # if defined (ACE_HAS_PTHREADS_UNIX98_EXT)
00659 return ACE_OS::thread_mutex_init (m, PTHREAD_MUTEX_RECURSIVE, name, arg);
00660 # else
00661 return ACE_OS::thread_mutex_init (m, 0, name, arg);
00662 # endif
00663 # else
00664 if (ACE_OS::thread_mutex_init (&m->nesting_mutex_, 0, name, arg) == -1)
00665 return -1;
00666 else if (ACE_OS::cond_init (&m->lock_available_,
00667 (short) USYNC_THREAD,
00668 name,
00669 0) == -1)
00670 return -1;
00671 else
00672 {
00673 m->nesting_level_ = 0;
00674 m->owner_id_ = ACE_OS::NULL_thread;
00675 return 0;
00676 }
00677 # endif
00678 #else
00679 ACE_UNUSED_ARG (m);
00680 ACE_UNUSED_ARG (name);
00681 ACE_UNUSED_ARG (arg);
00682 ACE_NOTSUP_RETURN (-1);
00683 #endif
00684 }
00685
00686 ACE_INLINE int
00687 ACE_OS::recursive_mutex_lock (ACE_recursive_thread_mutex_t *m)
00688 {
00689 #if defined (ACE_HAS_THREADS)
00690 #if defined (ACE_HAS_RECURSIVE_MUTEXES)
00691 return ACE_OS::thread_mutex_lock (m);
00692 #else
00693 ACE_thread_t const t_id = ACE_OS::thr_self ();
00694 int result = 0;
00695
00696
00697 if (ACE_OS::thread_mutex_lock (&m->nesting_mutex_) == -1)
00698 result = -1;
00699 else
00700 {
00701
00702
00703 if (m->nesting_level_ == 0)
00704 m->owner_id_ = t_id;
00705
00706
00707 else if (ACE_OS::thr_equal (t_id, m->owner_id_) == 0)
00708 {
00709
00710
00711 while (m->nesting_level_ > 0)
00712 ACE_OS::cond_wait (&m->lock_available_,
00713 &m->nesting_mutex_);
00714
00715
00716 m->owner_id_ = t_id;
00717 }
00718
00719
00720
00721 ++m->nesting_level_;
00722 }
00723
00724 {
00725
00726 ACE_Errno_Guard error (errno);
00727 ACE_OS::thread_mutex_unlock (&m->nesting_mutex_);
00728 }
00729 return result;
00730 #endif
00731 #else
00732 ACE_UNUSED_ARG (m);
00733 ACE_NOTSUP_RETURN (-1);
00734 #endif
00735 }
00736
00737 ACE_INLINE int
00738 ACE_OS::recursive_mutex_lock (ACE_recursive_thread_mutex_t *m,
00739 const ACE_Time_Value &timeout)
00740 {
00741 #if defined (ACE_HAS_THREADS)
00742 #if defined (ACE_HAS_RECURSIVE_MUTEXES)
00743 return ACE_OS::thread_mutex_lock (m, timeout);
00744 #else
00745 ACE_thread_t t_id = ACE_OS::thr_self ();
00746 int result = 0;
00747
00748
00749 if (ACE_OS::thread_mutex_lock (&m->nesting_mutex_, timeout) == -1)
00750 result = -1;
00751 else
00752 {
00753
00754
00755 if (m->nesting_level_ == 0)
00756 m->owner_id_ = t_id;
00757
00758
00759 else if (ACE_OS::thr_equal (t_id, m->owner_id_) == 0)
00760 {
00761
00762
00763 while (m->nesting_level_ > 0)
00764 {
00765 result = ACE_OS::cond_timedwait (&m->lock_available_,
00766 &m->nesting_mutex_,
00767 const_cast <ACE_Time_Value *> (&timeout));
00768
00769
00770
00771 if (result == -1)
00772 {
00773
00774 ACE_Errno_Guard error (errno);
00775 ACE_OS::thread_mutex_unlock (&m->nesting_mutex_);
00776
00777 return result;
00778 }
00779 }
00780
00781
00782 m->owner_id_ = t_id;
00783 }
00784
00785
00786
00787 m->nesting_level_++;
00788
00789
00790 ACE_Errno_Guard error (errno);
00791 ACE_OS::thread_mutex_unlock (&m->nesting_mutex_);
00792 }
00793 return result;
00794 #endif
00795 #else
00796 ACE_UNUSED_ARG (m);
00797 ACE_UNUSED_ARG (timeout);
00798 ACE_NOTSUP_RETURN (-1);
00799 #endif
00800 }
00801
00802 ACE_INLINE int
00803 ACE_OS::recursive_mutex_lock (ACE_recursive_thread_mutex_t *m,
00804 const ACE_Time_Value *timeout)
00805 {
00806 return timeout == 0
00807 ? ACE_OS::recursive_mutex_lock (m)
00808 : ACE_OS::recursive_mutex_lock (m, *timeout);
00809 }
00810
00811 ACE_INLINE int
00812 ACE_OS::recursive_mutex_trylock (ACE_recursive_thread_mutex_t *m)
00813 {
00814 #if defined (ACE_HAS_THREADS)
00815 #if defined (ACE_HAS_RECURSIVE_MUTEXES)
00816 return ACE_OS::thread_mutex_trylock (m);
00817 #else
00818 ACE_thread_t t_id = ACE_OS::thr_self ();
00819 int result = 0;
00820
00821
00822 if (ACE_OS::thread_mutex_lock (&m->nesting_mutex_) == -1)
00823 result = -1;
00824 else
00825 {
00826
00827 if (m->nesting_level_ == 0)
00828 {
00829 m->owner_id_ = t_id;
00830 m->nesting_level_ = 1;
00831 }
00832
00833
00834 else if (ACE_OS::thr_equal (t_id, m->owner_id_))
00835 m->nesting_level_++;
00836 else
00837 {
00838 errno = EBUSY;
00839 result = -1;
00840 }
00841 }
00842
00843 {
00844
00845 ACE_Errno_Guard error (errno);
00846 ACE_OS::thread_mutex_unlock (&m->nesting_mutex_);
00847 }
00848 return result;
00849 #endif
00850 #else
00851 ACE_UNUSED_ARG (m);
00852 ACE_NOTSUP_RETURN (-1);
00853 #endif
00854 }
00855
00856 ACE_INLINE int
00857 ACE_OS::recursive_mutex_unlock (ACE_recursive_thread_mutex_t *m)
00858 {
00859 #if defined (ACE_HAS_THREADS)
00860 # if defined (ACE_HAS_RECURSIVE_MUTEXES)
00861 return ACE_OS::thread_mutex_unlock (m);
00862 # else
00863 ACE_OS_TRACE ("ACE_OS::recursive_mutex_unlock");
00864 # if !defined (ACE_NDEBUG)
00865 ACE_thread_t t_id = ACE_OS::thr_self ();
00866 # endif
00867 int result = 0;
00868
00869 if (ACE_OS::thread_mutex_lock (&m->nesting_mutex_) == -1)
00870 result = -1;
00871 else
00872 {
00873 # if !defined (ACE_NDEBUG)
00874 if (m->nesting_level_ == 0
00875 || ACE_OS::thr_equal (t_id, m->owner_id_) == 0)
00876 {
00877 errno = EINVAL;
00878 result = -1;
00879 }
00880 else
00881 # endif
00882 {
00883 m->nesting_level_--;
00884 if (m->nesting_level_ == 0)
00885 {
00886
00887
00888 m->owner_id_ = ACE_OS::NULL_thread;
00889
00890
00891 if (ACE_OS::cond_signal (&m->lock_available_) == -1)
00892 result = -1;
00893 }
00894 }
00895 }
00896
00897 {
00898
00899 ACE_Errno_Guard error (errno);
00900 ACE_OS::thread_mutex_unlock (&m->nesting_mutex_);
00901 }
00902 return result;
00903 # endif
00904 #else
00905 ACE_UNUSED_ARG (m);
00906 ACE_NOTSUP_RETURN (-1);
00907 #endif
00908 }
00909
00910 ACE_INLINE int
00911 ACE_OS::rw_rdlock (ACE_rwlock_t *rw)
00912 {
00913 ACE_OS_TRACE ("ACE_OS::rw_rdlock");
00914 #if defined (ACE_HAS_THREADS)
00915 # if !defined (ACE_LACKS_RWLOCK_T) || defined (ACE_HAS_PTHREADS_UNIX98_EXT)
00916 # if defined (ACE_HAS_PTHREADS_UNIX98_EXT)
00917 int result;
00918 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_rdlock (rw),
00919 result),
00920 int, -1);
00921 # else
00922 int result;
00923 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rw_rdlock (rw), result), int, -1);
00924 # endif
00925 # else
00926 # if defined (ACE_HAS_PTHREADS)
00927 ACE_PTHREAD_CLEANUP_PUSH (&rw->lock_);
00928 # endif
00929 int result = 0;
00930 if (ACE_OS::mutex_lock (&rw->lock_) == -1)
00931 result = -1;
00932 else
00933 {
00934
00935 while (rw->ref_count_ < 0 || rw->num_waiting_writers_ > 0)
00936 {
00937 rw->num_waiting_readers_++;
00938 if (ACE_OS::cond_wait (&rw->waiting_readers_, &rw->lock_) == -1)
00939 {
00940 result = -2;
00941 break;
00942 }
00943 rw->num_waiting_readers_--;
00944 }
00945 }
00946 if (result == 0)
00947 rw->ref_count_++;
00948 if (result != -1)
00949 ACE_OS::mutex_unlock (&rw->lock_);
00950 # if defined (ACE_HAS_PTHREADS)
00951 ACE_PTHREAD_CLEANUP_POP (0);
00952 # endif
00953 return 0;
00954 # endif
00955 #else
00956 ACE_UNUSED_ARG (rw);
00957 ACE_NOTSUP_RETURN (-1);
00958 #endif
00959 }
00960
00961 ACE_INLINE int
00962 ACE_OS::rw_tryrdlock (ACE_rwlock_t *rw)
00963 {
00964 ACE_OS_TRACE ("ACE_OS::rw_tryrdlock");
00965 #if defined (ACE_HAS_THREADS)
00966 # if !defined (ACE_LACKS_RWLOCK_T) || defined (ACE_HAS_PTHREADS_UNIX98_EXT)
00967 # if defined (ACE_HAS_PTHREADS_UNIX98_EXT)
00968 int result;
00969 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_tryrdlock (rw),
00970 result),
00971 int, -1);
00972 # else
00973 int result;
00974 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rw_tryrdlock (rw), result), int, -1);
00975 # endif
00976 # else
00977 int result = -1;
00978
00979 if (ACE_OS::mutex_lock (&rw->lock_) != -1)
00980 {
00981 ACE_Errno_Guard error (errno);
00982
00983 if (rw->ref_count_ == -1 || rw->num_waiting_writers_ > 0)
00984 {
00985 error = EBUSY;
00986 result = -1;
00987 }
00988 else
00989 {
00990 rw->ref_count_++;
00991 result = 0;
00992 }
00993
00994 ACE_OS::mutex_unlock (&rw->lock_);
00995 }
00996 return result;
00997 # endif
00998 #else
00999 ACE_UNUSED_ARG (rw);
01000 ACE_NOTSUP_RETURN (-1);
01001 #endif
01002 }
01003
01004 ACE_INLINE int
01005 ACE_OS::rw_trywrlock (ACE_rwlock_t *rw)
01006 {
01007 ACE_OS_TRACE ("ACE_OS::rw_trywrlock");
01008 #if defined (ACE_HAS_THREADS)
01009 # if !defined (ACE_LACKS_RWLOCK_T) || defined (ACE_HAS_PTHREADS_UNIX98_EXT)
01010 # if defined (ACE_HAS_PTHREADS_UNIX98_EXT)
01011 int result;
01012 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_trywrlock (rw),
01013 result),
01014 int, -1);
01015 # else
01016 int result;
01017 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rw_trywrlock (rw), result), int, -1);
01018 # endif
01019 # else
01020 int result = -1;
01021
01022 if (ACE_OS::mutex_lock (&rw->lock_) != -1)
01023 {
01024 ACE_Errno_Guard error (errno);
01025
01026 if (rw->ref_count_ != 0)
01027 {
01028 error = EBUSY;
01029 result = -1;
01030 }
01031 else
01032 {
01033 rw->ref_count_ = -1;
01034 result = 0;
01035 }
01036
01037 ACE_OS::mutex_unlock (&rw->lock_);
01038 }
01039 return result;
01040 # endif
01041 #else
01042 ACE_UNUSED_ARG (rw);
01043 ACE_NOTSUP_RETURN (-1);
01044 #endif
01045 }
01046
01047
01048
01049
01050
01051
01052
01053 ACE_INLINE int
01054 ACE_OS::rw_trywrlock_upgrade (ACE_rwlock_t *rw)
01055 {
01056 ACE_OS_TRACE ("ACE_OS::rw_trywrlock_upgrade");
01057 #if defined (ACE_HAS_THREADS)
01058 # if defined (ACE_HAS_PTHREADS_UNIX98_EXT)
01059
01060
01061 int result;
01062 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_trywrlock (rw),
01063 result),
01064 int, -1);
01065 # elif !defined (ACE_LACKS_RWLOCK_T)
01066
01067
01068 ACE_UNUSED_ARG (rw);
01069 ACE_NOTSUP_RETURN (-1);
01070 # else
01071
01072 int result = 0;
01073
01074 # if defined (ACE_HAS_PTHREADS)
01075 ACE_PTHREAD_CLEANUP_PUSH (&rw->lock_);
01076 # endif
01077
01078 if (ACE_OS::mutex_lock (&rw->lock_) == -1)
01079 return -1;
01080
01081 else if (rw->important_writer_)
01082
01083 {
01084 result = -1;
01085 errno = EBUSY;
01086 }
01087 else
01088 {
01089 while (rw->ref_count_ > 1)
01090 {
01091 rw->num_waiting_writers_++;
01092 rw->important_writer_ = true;
01093
01094 if (ACE_OS::cond_wait (&rw->waiting_important_writer_, &rw->lock_) == -1)
01095 {
01096 result = -1;
01097
01098
01099 }
01100 rw->important_writer_ = false;
01101 rw->num_waiting_writers_--;
01102 }
01103 if (result == 0)
01104 {
01105
01106 rw->ref_count_ = -1;
01107
01108
01109 }
01110 }
01111
01112 ACE_OS::mutex_unlock (&rw->lock_);
01113
01114 # if defined (ACE_HAS_PTHREADS)
01115 ACE_PTHREAD_CLEANUP_POP (0);
01116 # endif
01117
01118 return result;
01119
01120 # endif
01121 #else
01122 ACE_UNUSED_ARG (rw);
01123 ACE_NOTSUP_RETURN (-1);
01124 #endif
01125 }
01126
01127 ACE_INLINE int
01128 ACE_OS::rw_unlock (ACE_rwlock_t *rw)
01129 {
01130 ACE_OS_TRACE ("ACE_OS::rw_unlock");
01131 #if defined (ACE_HAS_THREADS)
01132 # if !defined (ACE_LACKS_RWLOCK_T) || defined (ACE_HAS_PTHREADS_UNIX98_EXT)
01133 # if defined (ACE_HAS_PTHREADS_UNIX98_EXT)
01134 int result;
01135 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_unlock (rw),
01136 result),
01137 int, -1);
01138 # else
01139 int result;
01140 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rw_unlock (rw), result), int, -1);
01141 # endif
01142 # else
01143 if (ACE_OS::mutex_lock (&rw->lock_) == -1)
01144 return -1;
01145
01146 if (rw->ref_count_ > 0)
01147 rw->ref_count_--;
01148 else if (rw->ref_count_ == -1)
01149 rw->ref_count_ = 0;
01150 else
01151 {
01152 (void) ACE_OS::mutex_unlock (&rw->lock_);
01153 return -1;
01154 }
01155
01156 int result = 0;
01157 ACE_Errno_Guard error (errno);
01158
01159 if (rw->important_writer_ && rw->ref_count_ == 1)
01160
01161 {
01162 result = ACE_OS::cond_signal (&rw->waiting_important_writer_);
01163 error = errno;
01164 }
01165 else if (rw->num_waiting_writers_ > 0 && rw->ref_count_ == 0)
01166
01167 {
01168 result = ACE_OS::cond_signal (&rw->waiting_writers_);
01169 error = errno;
01170 }
01171 else if (rw->num_waiting_readers_ > 0 && rw->num_waiting_writers_ == 0)
01172 {
01173 result = ACE_OS::cond_broadcast (&rw->waiting_readers_);
01174 error = errno;
01175 }
01176
01177 (void) ACE_OS::mutex_unlock (&rw->lock_);
01178 return result;
01179 # endif
01180 #else
01181 ACE_UNUSED_ARG (rw);
01182 ACE_NOTSUP_RETURN (-1);
01183 #endif
01184 }
01185
01186 ACE_INLINE int
01187 ACE_OS::rw_wrlock (ACE_rwlock_t *rw)
01188 {
01189 ACE_OS_TRACE ("ACE_OS::rw_wrlock");
01190 #if defined (ACE_HAS_THREADS)
01191 # if !defined (ACE_LACKS_RWLOCK_T) || defined (ACE_HAS_PTHREADS_UNIX98_EXT)
01192 # if defined (ACE_HAS_PTHREADS_UNIX98_EXT)
01193 int result;
01194 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_wrlock (rw),
01195 result),
01196 int, -1);
01197 # else
01198 int result;
01199 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rw_wrlock (rw), result), int, -1);
01200 # endif
01201 # else
01202 # if defined (ACE_HAS_PTHREADS)
01203 ACE_PTHREAD_CLEANUP_PUSH (&rw->lock_);
01204 # endif
01205 int result = 0;
01206
01207 if (ACE_OS::mutex_lock (&rw->lock_) == -1)
01208 result = -1;
01209 else
01210 {
01211 while (rw->ref_count_ != 0)
01212 {
01213 rw->num_waiting_writers_++;
01214
01215 if (ACE_OS::cond_wait (&rw->waiting_writers_, &rw->lock_) == -1)
01216 {
01217 result = -2;
01218 break;
01219 }
01220
01221 rw->num_waiting_writers_--;
01222 }
01223 }
01224 if (result == 0)
01225 rw->ref_count_ = -1;
01226 if (result != -1)
01227 ACE_OS::mutex_unlock (&rw->lock_);
01228 # if defined (ACE_HAS_PTHREADS)
01229 ACE_PTHREAD_CLEANUP_POP (0);
01230 # endif
01231 return 0;
01232 # endif
01233 #else
01234 ACE_UNUSED_ARG (rw);
01235 ACE_NOTSUP_RETURN (-1);
01236 #endif
01237 }
01238
01239 ACE_INLINE int
01240 ACE_OS::rwlock_destroy (ACE_rwlock_t *rw)
01241 {
01242 ACE_OS_TRACE ("ACE_OS::rwlock_destroy");
01243 #if defined (ACE_HAS_THREADS)
01244 # if !defined (ACE_LACKS_RWLOCK_T) || defined (ACE_HAS_PTHREADS_UNIX98_EXT)
01245 # if defined (ACE_HAS_PTHREADS_UNIX98_EXT)
01246 int result;
01247 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_rwlock_destroy (rw),
01248 result),
01249 int, -1);
01250 # else
01251 int result;
01252 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rwlock_destroy (rw), result), int, -1);
01253 # endif
01254 # else
01255 ACE_OS::mutex_destroy (&rw->lock_);
01256 ACE_OS::cond_destroy (&rw->waiting_readers_);
01257 ACE_OS::cond_destroy (&rw->waiting_important_writer_);
01258 return ACE_OS::cond_destroy (&rw->waiting_writers_);
01259 # endif
01260 #else
01261 ACE_UNUSED_ARG (rw);
01262 ACE_NOTSUP_RETURN (-1);
01263 #endif
01264 }
01265
01266 #if defined (ACE_HAS_THREADS) && (!defined (ACE_LACKS_RWLOCK_T) || \
01267 defined (ACE_HAS_PTHREADS_UNIX98_EXT))
01268 ACE_INLINE int
01269 ACE_OS::rwlock_init (ACE_rwlock_t *rw,
01270 int type,
01271 const ACE_TCHAR *name,
01272 void *arg)
01273 {
01274
01275 # if defined (ACE_HAS_PTHREADS_UNIX98_EXT)
01276 ACE_UNUSED_ARG (name);
01277 ACE_UNUSED_ARG (arg);
01278
01279 int status;
01280 pthread_rwlockattr_t attr;
01281 pthread_rwlockattr_init (&attr);
01282 # if !defined (ACE_LACKS_RWLOCKATTR_PSHARED)
01283 pthread_rwlockattr_setpshared (&attr, (type == USYNC_THREAD ?
01284 PTHREAD_PROCESS_PRIVATE :
01285 PTHREAD_PROCESS_SHARED));
01286 # else
01287 ACE_UNUSED_ARG (type);
01288 # endif
01289 status = ACE_ADAPT_RETVAL (pthread_rwlock_init (rw, &attr), status);
01290 pthread_rwlockattr_destroy (&attr);
01291
01292 return status;
01293
01294 # else
01295 type = type;
01296 name = name;
01297 int result;
01298 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::rwlock_init (rw, type, arg), result), int, -1);
01299 # endif
01300 }
01301 #endif
01302
01303 ACE_INLINE int
01304 ACE_OS::sema_destroy (ACE_sema_t *s)
01305 {
01306 ACE_OS_TRACE ("ACE_OS::sema_destroy");
01307 # if defined (ACE_HAS_POSIX_SEM)
01308 int result;
01309 # if !defined (ACE_HAS_POSIX_SEM_TIMEOUT) && !defined (ACE_DISABLE_POSIX_SEM_TIMEOUT_EMULATION)
01310 ACE_OS::mutex_destroy (&s->lock_);
01311 ACE_OS::cond_destroy (&s->count_nonzero_);
01312 # endif
01313 # if defined (ACE_LACKS_NAMED_POSIX_SEM)
01314 if (s->name_)
01315 {
01316
01317
01318 ACE_OSCALL (::sem_destroy (s->sema_),int, -1, result);
01319 ACE_OS::shm_unlink (s->name_);
01320 delete s->name_;
01321 return result;
01322 }
01323 # else
01324 if (s->name_)
01325 {
01326 ACE_OSCALL (::sem_unlink (s->name_), int, -1, result);
01327 ACE_OS::free ((void *) s->name_);
01328 ACE_OSCALL_RETURN (::sem_close (s->sema_), int, -1);
01329 }
01330 # endif
01331 else
01332 {
01333 ACE_OSCALL (::sem_destroy (s->sema_), int, -1, result);
01334 # if defined (ACE_LACKS_NAMED_POSIX_SEM)
01335 if (s->new_sema_)
01336 # endif
01337 delete s->sema_;
01338 s->sema_ = 0;
01339 return result;
01340 }
01341 # elif defined (ACE_USES_FIFO_SEM)
01342 int r0 = 0;
01343 if (s->name_)
01344 {
01345 r0 = ACE_OS::unlink (s->name_);
01346 ACE_OS::free (s->name_);
01347 s->name_ = 0;
01348 }
01349 int r1 = ACE_OS::close (s->fd_[0]);
01350 int r2 = ACE_OS::close (s->fd_[1]);
01351 return r0 != 0 || r1 != 0 || r2 != 0 ? -1 : 0;
01352 # elif defined (ACE_HAS_THREADS)
01353 # if defined (ACE_HAS_STHREADS)
01354 int result;
01355 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sema_destroy (s), result), int, -1);
01356 # elif defined (ACE_HAS_PTHREADS)
01357 int r1 = ACE_OS::mutex_destroy (&s->lock_);
01358 int r2 = ACE_OS::cond_destroy (&s->count_nonzero_);
01359 return r1 != 0 || r2 != 0 ? -1 : 0;
01360 # elif defined (ACE_HAS_WTHREADS)
01361 # if !defined (ACE_USES_WINCE_SEMA_SIMULATION)
01362 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::CloseHandle (*s), ace_result_), int, -1);
01363 # else
01364
01365 int const r1 = ACE_OS::thread_mutex_destroy (&s->lock_);
01366 int const r2 = ACE_OS::event_destroy (&s->count_nonzero_);
01367 return r1 != 0 || r2 != 0 ? -1 : 0;
01368 # endif
01369 # elif defined (ACE_VXWORKS)
01370 int result;
01371 ACE_OSCALL (::semDelete (s->sema_), int, -1, result);
01372 s->sema_ = 0;
01373 return result;
01374 # endif
01375 # else
01376 ACE_UNUSED_ARG (s);
01377 ACE_NOTSUP_RETURN (-1);
01378 # endif
01379 }
01380
01381
01382
01383
01384 ACE_INLINE int
01385 ACE_OS::sema_init (ACE_sema_t *s,
01386 u_int count,
01387 int type,
01388 const char *name,
01389 void *arg,
01390 int max,
01391 LPSECURITY_ATTRIBUTES sa)
01392 {
01393 ACE_OS_TRACE ("ACE_OS::sema_init");
01394 #if defined (ACE_HAS_POSIX_SEM)
01395 ACE_UNUSED_ARG (max);
01396 ACE_UNUSED_ARG (sa);
01397
01398 s->name_ = 0;
01399 # if defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_DISABLE_POSIX_SEM_TIMEOUT_EMULATION)
01400 ACE_UNUSED_ARG (arg);
01401 # else
01402 int result = -1;
01403
01404 if (ACE_OS::mutex_init (&s->lock_, type, name,
01405 (ACE_mutexattr_t *) arg) == 0
01406 && ACE_OS::cond_init (&s->count_nonzero_, (short)type, name, arg) == 0
01407 && ACE_OS::mutex_lock (&s->lock_) == 0)
01408 {
01409 if (ACE_OS::mutex_unlock (&s->lock_) == 0)
01410 result = 0;
01411 }
01412
01413 if (result == -1)
01414 {
01415 ACE_OS::mutex_destroy (&s->lock_);
01416 ACE_OS::cond_destroy (&s->count_nonzero_);
01417 return result;
01418 }
01419 # endif
01420
01421 # if defined (ACE_LACKS_NAMED_POSIX_SEM)
01422 s->new_sema_ = false;
01423 if (type == USYNC_PROCESS)
01424 {
01425
01426 ACE_HANDLE fd = ACE_OS::shm_open (ACE_TEXT_CHAR_TO_TCHAR (name),
01427 O_RDWR | O_CREAT | O_EXCL,
01428 ACE_DEFAULT_FILE_PERMS);
01429 if (fd == ACE_INVALID_HANDLE)
01430 {
01431 if (errno == EEXIST)
01432 fd = ACE_OS::shm_open (ACE_TEXT_CHAR_TO_TCHAR (name),
01433 O_RDWR | O_CREAT,
01434 ACE_DEFAULT_FILE_PERMS);
01435 else
01436 return -1;
01437 }
01438 else
01439 {
01440
01441
01442 if (ACE_OS::ftruncate (fd,
01443 sizeof (ACE_sema_t)) == -1)
01444 return -1;
01445 s->name_ = ACE_OS::strdup (name);
01446 if (s->name_ == 0)
01447 return -1;
01448 }
01449 if (fd == -1)
01450 return -1;
01451
01452 s->sema_ = (sem_t *)
01453 ACE_OS::mmap (0,
01454 sizeof (ACE_sema_t),
01455 PROT_RDWR,
01456 MAP_SHARED,
01457 fd,
01458 0);
01459 ACE_OS::close (fd);
01460 if (s->sema_ == (sem_t *) MAP_FAILED)
01461 return -1;
01462 if (s->name_
01463
01464
01465
01466
01467
01468
01469
01470 && ::sem_init (s->sema_, type == USYNC_PROCESS, count) == -1)
01471 return -1;
01472 return 0;
01473 }
01474 # else
01475 if (name)
01476 {
01477 # if defined (sun) || defined (HPUX)
01478
01479
01480 const char *last_slash = ACE_OS::strrchr (name, '/');
01481 char name2[MAXPATHLEN];
01482 if (0 == last_slash)
01483 {
01484 ACE_OS::strcpy (name2, "/");
01485 ACE_OS::strcat (name2, name);
01486 name = name2;
01487 }
01488 # if defined (sun)
01489 else
01490 name = last_slash;
01491 # endif
01492 # endif
01493
01494 ACE_ALLOCATOR_RETURN (s->name_,
01495 ACE_OS::strdup (name),
01496 -1);
01497 s->sema_ = ::sem_open (s->name_,
01498 O_CREAT,
01499 ACE_DEFAULT_FILE_PERMS,
01500 count);
01501 if (s->sema_ == (sem_t *) SEM_FAILED)
01502 return -1;
01503 else
01504 return 0;
01505 }
01506 # endif
01507 else
01508 {
01509 ACE_NEW_RETURN (s->sema_,
01510 sem_t,
01511 -1);
01512 # if defined (ACE_LACKS_NAMED_POSIX_SEM)
01513 s->new_sema_ = true;
01514 # endif
01515 ACE_OSCALL_RETURN (::sem_init (s->sema_,
01516 type != USYNC_THREAD,
01517 count), int, -1);
01518 }
01519
01520 #elif defined (ACE_USES_FIFO_SEM)
01521 ACE_UNUSED_ARG (arg);
01522 ACE_UNUSED_ARG (max);
01523 ACE_UNUSED_ARG (sa);
01524 int flags = 0;
01525 mode_t mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP;
01526
01527 if (type == USYNC_THREAD)
01528 {
01529
01530 char uname[ACE_UNIQUE_NAME_LEN];
01531 ACE_OS::unique_name ((const void *) s,
01532 uname,
01533 ACE_UNIQUE_NAME_LEN);
01534 name = &uname[0];
01535 }
01536
01537 s->name_ = 0;
01538 s->fd_[0] = s->fd_[1] = ACE_INVALID_HANDLE;
01539 bool creator = false;
01540
01541 if (ACE_OS::mkfifo (ACE_TEXT_CHAR_TO_TCHAR (name), mode) < 0)
01542 {
01543 if (errno != EEXIST)
01544 return -1;
01545
01546 ACE_stat fs;
01547 if (ACE_OS::stat (name, &fs))
01548 return -1;
01549 if (!S_ISFIFO (fs.st_mode))
01550 {
01551
01552 errno = EEXIST;
01553 return -1;
01554 }
01555 }
01556 else
01557 creator = true;
01558
01559
01560
01561 if (type == USYNC_PROCESS)
01562 {
01563 s->name_ = ACE_OS::strdup (name);
01564 if (s->name_ == 0)
01565 {
01566 if (creator)
01567 ACE_OS::unlink (name);
01568 return -1;
01569 }
01570 }
01571
01572 if ((s->fd_[0] = ACE_OS::open (name, O_RDONLY | O_NONBLOCK)) == ACE_INVALID_HANDLE
01573 || (s->fd_[1] = ACE_OS::open (name, O_WRONLY | O_NONBLOCK)) == ACE_INVALID_HANDLE)
01574 return -1;
01575
01576
01577 if ((flags = ACE_OS::fcntl (s->fd_[0], F_GETFL, 0)) < 0)
01578 return -1;
01579
01580 flags &= ~O_NONBLOCK;
01581 if (ACE_OS::fcntl (s->fd_[0], F_SETFL, flags) < 0)
01582 return -1;
01583
01584
01585 if (creator && count)
01586 {
01587 char c = 1;
01588 for (u_int i=0; i<count ;++i)
01589 if (ACE_OS::write (s->fd_[1], &c, sizeof (char)) != 1)
01590 return -1;
01591 }
01592
01593
01594
01595
01596
01597
01598
01599 if (type == USYNC_THREAD)
01600 {
01601 ACE_OS::unlink (name);
01602 }
01603
01604 return 0;
01605 #elif defined (ACE_HAS_THREADS)
01606 # if defined (ACE_HAS_STHREADS)
01607 ACE_UNUSED_ARG (name);
01608 ACE_UNUSED_ARG (max);
01609 ACE_UNUSED_ARG (sa);
01610 int result;
01611 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sema_init (s, count, type, arg), result),
01612 int, -1);
01613 # elif defined (ACE_HAS_PTHREADS)
01614 ACE_UNUSED_ARG (max);
01615 ACE_UNUSED_ARG (sa);
01616 int result = -1;
01617
01618 if (ACE_OS::mutex_init (&s->lock_, type, name,
01619 (ACE_mutexattr_t *) arg) == 0
01620 && ACE_OS::cond_init (&s->count_nonzero_, type, name, arg) == 0
01621 && ACE_OS::mutex_lock (&s->lock_) == 0)
01622 {
01623 s->count_ = count;
01624 s->waiters_ = 0;
01625
01626 if (ACE_OS::mutex_unlock (&s->lock_) == 0)
01627 result = 0;
01628 }
01629
01630 if (result == -1)
01631 {
01632 ACE_OS::mutex_destroy (&s->lock_);
01633 ACE_OS::cond_destroy (&s->count_nonzero_);
01634 }
01635 return result;
01636 # elif defined (ACE_HAS_WTHREADS)
01637 # if ! defined (ACE_USES_WINCE_SEMA_SIMULATION)
01638 ACE_UNUSED_ARG (type);
01639 ACE_UNUSED_ARG (arg);
01640
01641
01642 SECURITY_ATTRIBUTES sa_buffer;
01643 SECURITY_DESCRIPTOR sd_buffer;
01644 *s = ACE_TEXT_CreateSemaphore
01645 (ACE_OS::default_win32_security_attributes_r (sa, &sa_buffer, &sd_buffer),
01646 count,
01647 max,
01648 ACE_TEXT_CHAR_TO_TCHAR (name));
01649
01650 if (*s == 0)
01651 ACE_FAIL_RETURN (-1);
01652
01653 else
01654 {
01655
01656 ACE_OS::set_errno_to_last_error ();
01657 return 0;
01658 }
01659 # else
01660 int result = -1;
01661
01662
01663
01664
01665
01666
01667
01668
01669
01670
01671
01672 if (ACE_OS::thread_mutex_init (&s->lock_, type, name, (ACE_mutexattr_t *)arg) == 0
01673 && ACE_OS::event_init (&s->count_nonzero_, 1,
01674 count > 0, type, name, arg, sa) == 0
01675 && ACE_OS::thread_mutex_lock (&s->lock_) == 0)
01676 {
01677 s->count_ = count;
01678
01679 if (ACE_OS::thread_mutex_unlock (&s->lock_) == 0)
01680 result = 0;
01681 }
01682
01683
01684
01685
01686 if (result == -1)
01687 {
01688 ACE_OS::thread_mutex_destroy (&s->lock_);
01689 ACE_OS::event_destroy (&s->count_nonzero_);
01690 }
01691 return result;
01692 # endif
01693 # elif defined (ACE_VXWORKS)
01694 ACE_UNUSED_ARG (name);
01695 ACE_UNUSED_ARG (arg);
01696 ACE_UNUSED_ARG (max);
01697 ACE_UNUSED_ARG (sa);
01698 s->name_ = 0;
01699 s->sema_ = ::semCCreate (type, count);
01700 return s->sema_ ? 0 : -1;
01701 # endif
01702 #else
01703 ACE_UNUSED_ARG (s);
01704 ACE_UNUSED_ARG (count);
01705 ACE_UNUSED_ARG (type);
01706 ACE_UNUSED_ARG (name);
01707 ACE_UNUSED_ARG (arg);
01708 ACE_UNUSED_ARG (max);
01709 ACE_UNUSED_ARG (sa);
01710 ACE_NOTSUP_RETURN (-1);
01711 #endif
01712 }
01713
01714 #if defined (ACE_HAS_WCHAR)
01715 ACE_INLINE int
01716 ACE_OS::sema_init (ACE_sema_t *s,
01717 u_int count,
01718 int type,
01719 const wchar_t *name,
01720 void *arg,
01721 int max,
01722 LPSECURITY_ATTRIBUTES sa)
01723 {
01724 # if defined (ACE_HAS_WTHREADS)
01725 # if ! defined (ACE_USES_WINCE_SEMA_SIMULATION)
01726 ACE_UNUSED_ARG (type);
01727 ACE_UNUSED_ARG (arg);
01728
01729
01730 SECURITY_ATTRIBUTES sa_buffer;
01731 SECURITY_DESCRIPTOR sd_buffer;
01732 *s = ::CreateSemaphoreW
01733 (ACE_OS::default_win32_security_attributes_r (sa, &sa_buffer, &sd_buffer),
01734 count,
01735 max,
01736 name);
01737
01738 if (*s == 0)
01739 ACE_FAIL_RETURN (-1);
01740
01741 else
01742 {
01743
01744 ACE_OS::set_errno_to_last_error ();
01745 return 0;
01746 }
01747 # else
01748 int result = -1;
01749
01750
01751
01752
01753
01754
01755
01756
01757
01758
01759
01760 if (ACE_OS::thread_mutex_init (&s->lock_, type, name, (ACE_mutexattr_t *)arg) == 0
01761 && ACE_OS::event_init (&s->count_nonzero_, 1,
01762 count > 0, type, name, arg, sa) == 0
01763 && ACE_OS::thread_mutex_lock (&s->lock_) == 0)
01764 {
01765 s->count_ = count;
01766
01767 if (ACE_OS::thread_mutex_unlock (&s->lock_) == 0)
01768 result = 0;
01769 }
01770
01771
01772
01773
01774 if (result == -1)
01775 {
01776 ACE_OS::thread_mutex_destroy (&s->lock_);
01777 ACE_OS::event_destroy (&s->count_nonzero_);
01778 }
01779 return result;
01780 # endif
01781 # else
01782
01783 return ACE_OS::sema_init (s, count, type, ACE_Wide_To_Ascii (name).char_rep (), arg, max, sa);
01784 # endif
01785 }
01786 #endif
01787
01788 ACE_INLINE int
01789 ACE_OS::sema_post (ACE_sema_t *s)
01790 {
01791 ACE_OS_TRACE ("ACE_OS::sema_post");
01792 # if defined (ACE_HAS_POSIX_SEM)
01793 # if defined (ACE_HAS_POSIX_SEM_TIMEOUT) || defined (ACE_DISABLE_POSIX_SEM_TIMEOUT_EMULATION)
01794 ACE_OSCALL_RETURN (::sem_post (s->sema_), int, -1);
01795 # else
01796 int result = -1;
01797
01798 if (ACE_OS::mutex_lock (&s->lock_) == 0)
01799 {
01800 if (::sem_post (s->sema_) == 0)
01801 result = ACE_OS::cond_signal (&s->count_nonzero_);
01802
01803 ACE_OS::mutex_unlock (&s->lock_);
01804 }
01805 return result;
01806 # endif
01807 # elif defined (ACE_USES_FIFO_SEM)
01808 char c = 1;
01809 if (ACE_OS::write (s->fd_[1], &c, sizeof (char)) == sizeof (char))
01810 return 0;
01811 return -1;
01812 # elif defined (ACE_HAS_THREADS)
01813 # if defined (ACE_HAS_STHREADS)
01814 int result;
01815 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sema_post (s), result), int, -1);
01816 # elif defined (ACE_HAS_PTHREADS)
01817 int result = -1;
01818
01819 if (ACE_OS::mutex_lock (&s->lock_) == 0)
01820 {
01821
01822 if (s->waiters_ > 0)
01823 result = ACE_OS::cond_signal (&s->count_nonzero_);
01824 else
01825 result = 0;
01826
01827 s->count_++;
01828 ACE_OS::mutex_unlock (&s->lock_);
01829 }
01830 return result;
01831 # elif defined (ACE_HAS_WTHREADS)
01832 # if !defined (ACE_USES_WINCE_SEMA_SIMULATION)
01833 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::ReleaseSemaphore (*s, 1, 0),
01834 ace_result_),
01835 int, -1);
01836 # else
01837 int result = -1;
01838
01839
01840
01841 if (ACE_OS::thread_mutex_lock (&s->lock_) == 0)
01842 {
01843
01844
01845
01846 if (s->count_++ <= 0)
01847 result = ACE_OS::event_signal (&s->count_nonzero_);
01848 else
01849 result = 0;
01850
01851 ACE_OS::thread_mutex_unlock (&s->lock_);
01852 }
01853 return result;
01854 # endif
01855 # elif defined (ACE_VXWORKS)
01856 ACE_OSCALL_RETURN (::semGive (s->sema_), int, -1);
01857 # endif
01858 # else
01859 ACE_UNUSED_ARG (s);
01860 ACE_NOTSUP_RETURN (-1);
01861 # endif
01862 }
01863
01864 ACE_INLINE int
01865 ACE_OS::sema_post (ACE_sema_t *s, u_int release_count)
01866 {
01867 #if defined (ACE_WIN32) && !defined (ACE_USES_WINCE_SEMA_SIMULATION)
01868
01869 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::ReleaseSemaphore (*s, release_count, 0),
01870 ace_result_), int, -1);
01871 #else
01872
01873
01874
01875
01876
01877
01878
01879 for (size_t i = 0; i < release_count; i++)
01880 if (ACE_OS::sema_post (s) == -1)
01881 return -1;
01882
01883 return 0;
01884 #endif
01885 }
01886
01887 ACE_INLINE int
01888 ACE_OS::sema_trywait (ACE_sema_t *s)
01889 {
01890 ACE_OS_TRACE ("ACE_OS::sema_trywait");
01891 # if defined (ACE_HAS_POSIX_SEM)
01892
01893 ACE_OSCALL_RETURN (::sem_trywait (s->sema_), int, -1);
01894 # elif defined (ACE_USES_FIFO_SEM)
01895 char c;
01896 int rc, flags;
01897
01898
01899 if ((flags = ACE_OS::fcntl (s->fd_[0], F_GETFL, 0)) < 0)
01900 return -1;
01901 flags |= O_NONBLOCK;
01902 if (ACE_OS::fcntl (s->fd_[0], F_SETFL, flags) < 0)
01903 return -1;
01904
01905
01906 rc = ACE_OS::read (s->fd_[0], &c, sizeof (char));
01907
01908
01909 if ((flags = ACE_OS::fcntl (s->fd_[0], F_GETFL, 0)) >= 0)
01910 {
01911 flags &= ~O_NONBLOCK;
01912 ACE_OS::fcntl (s->fd_[0], F_SETFL, flags);
01913 }
01914
01915 return rc == 1 ? 0 : (-1);
01916 # elif defined (ACE_HAS_THREADS)
01917 # if defined (ACE_HAS_STHREADS)
01918
01919 int result;
01920 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sema_trywait (s),
01921 result),
01922 int, -1);
01923 # elif defined (ACE_HAS_PTHREADS)
01924
01925 int result = -1;
01926
01927 if (ACE_OS::mutex_lock (&s->lock_) == 0)
01928 {
01929 if (s->count_ > 0)
01930 {
01931 --s->count_;
01932 result = 0;
01933 }
01934 else
01935 errno = EBUSY;
01936
01937 ACE_OS::mutex_unlock (&s->lock_);
01938 }
01939 return result;
01940 # elif defined (ACE_HAS_WTHREADS)
01941 # if !defined (ACE_USES_WINCE_SEMA_SIMULATION)
01942 DWORD result = ::WaitForSingleObject (*s, 0);
01943
01944 if (result == WAIT_OBJECT_0)
01945 return 0;
01946 else
01947 {
01948 if (result == WAIT_TIMEOUT)
01949 errno = EBUSY;
01950 else
01951 ACE_OS::set_errno_to_last_error ();
01952
01953 return -1;
01954 }
01955 # else
01956
01957
01958
01959 DWORD result = ::WaitForSingleObject (s->count_nonzero_, 0);
01960
01961 if (result == WAIT_OBJECT_0)
01962 {
01963 ACE_OS::thread_mutex_lock (&s->lock_);
01964
01965
01966
01967
01968 result = ::WaitForSingleObject (s->count_nonzero_, 0);
01969 if (result == WAIT_OBJECT_0)
01970 {
01971
01972
01973 s->count_--;
01974 if (s->count_ <= 0)
01975 ACE_OS::event_reset (&s->count_nonzero_);
01976 result = 0;
01977 }
01978
01979 ACE_OS::thread_mutex_unlock (&s->lock_);
01980 }
01981
01982
01983 if (result == WAIT_TIMEOUT)
01984 errno = EBUSY;
01985 else
01986 ACE_OS::set_errno_to_last_error ();
01987
01988 return -1;
01989 # endif
01990 # elif defined (ACE_VXWORKS)
01991 if (::semTake (s->sema_, NO_WAIT) == ERROR)
01992 if (errno == S_objLib_OBJ_UNAVAILABLE)
01993 {
01994
01995 errno = EBUSY;
01996 return -1;
01997 }
01998 else
01999
02000 return -1;
02001 else
02002
02003 return 0;
02004 # endif
02005 # else
02006 ACE_UNUSED_ARG (s);
02007 ACE_NOTSUP_RETURN (-1);
02008 # endif
02009 }
02010
02011 ACE_INLINE int
02012 ACE_OS::sema_wait (ACE_sema_t *s)
02013 {
02014 ACE_OS_TRACE ("ACE_OS::sema_wait");
02015 # if defined (ACE_HAS_POSIX_SEM)
02016 ACE_OSCALL_RETURN (::sem_wait (s->sema_), int, -1);
02017 # elif defined (ACE_USES_FIFO_SEM)
02018 char c;
02019 if (ACE_OS::read (s->fd_[0], &c, sizeof (char)) == 1)
02020 return 0;
02021 return -1;
02022 # elif defined (ACE_HAS_THREADS)
02023 # if defined (ACE_HAS_STHREADS)
02024 int result;
02025 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sema_wait (s), result), int, -1);
02026 # elif defined (ACE_HAS_PTHREADS)
02027 int result = 0;
02028
02029 ACE_PTHREAD_CLEANUP_PUSH (&s->lock_);
02030
02031 if (ACE_OS::mutex_lock (&s->lock_) != 0)
02032 result = -1;
02033 else
02034 {
02035
02036
02037 s->waiters_++;
02038
02039
02040 while (s->count_ == 0)
02041 if (ACE_OS::cond_wait (&s->count_nonzero_,
02042 &s->lock_) == -1)
02043 {
02044 result = -2;
02045 break;
02046 }
02047
02048 --s->waiters_;
02049 }
02050
02051 if (result == 0)
02052 --s->count_;
02053
02054 if (result != -1)
02055 ACE_OS::mutex_unlock (&s->lock_);
02056 ACE_PTHREAD_CLEANUP_POP (0);
02057 return result < 0 ? -1 : result;
02058
02059 # elif defined (ACE_HAS_WTHREADS)
02060 # if !defined (ACE_USES_WINCE_SEMA_SIMULATION)
02061 switch (::WaitForSingleObject (*s, INFINITE))
02062 {
02063 case WAIT_OBJECT_0:
02064 return 0;
02065 default:
02066
02067 ACE_OS::set_errno_to_last_error ();
02068 return -1;
02069 }
02070
02071 # else
02072
02073 int result = -1;
02074 for (;;)
02075
02076
02077
02078 switch (::WaitForSingleObject (s->count_nonzero_, INFINITE))
02079 {
02080 case WAIT_OBJECT_0:
02081 ACE_OS::thread_mutex_lock (&s->lock_);
02082
02083
02084
02085 if (::WaitForSingleObject (s->count_nonzero_, 0) == WAIT_OBJECT_0)
02086 {
02087
02088
02089 s->count_--;
02090 if (s->count_ <= 0)
02091 ACE_OS::event_reset (&s->count_nonzero_);
02092 result = 0;
02093 }
02094
02095 ACE_OS::thread_mutex_unlock (&s->lock_);
02096
02097
02098 if (result == 0)
02099 return 0;
02100 break;
02101
02102 default:
02103
02104
02105 ACE_OS::set_errno_to_last_error ();
02106
02107 return -1;
02108 }
02109
02110 # endif
02111 # elif defined (ACE_VXWORKS)
02112 ACE_OSCALL_RETURN (::semTake (s->sema_, WAIT_FOREVER), int, -1);
02113 # endif
02114 # else
02115 ACE_UNUSED_ARG (s);
02116 ACE_NOTSUP_RETURN (-1);
02117 # endif
02118 }
02119
02120 ACE_INLINE int
02121 ACE_OS::sema_wait (ACE_sema_t *s, ACE_Time_Value &tv)
02122 {
02123 ACE_OS_TRACE ("ACE_OS::sema_wait");
02124 # if defined (ACE_HAS_POSIX_SEM)
02125 # if defined (ACE_HAS_POSIX_SEM_TIMEOUT)
02126 int rc;
02127 timespec_t ts;
02128 ts = tv;
02129 ACE_OSCALL (::sem_timedwait (s->sema_, &ts), int, -1, rc);
02130 if (rc == -1 && errno == ETIMEDOUT)
02131 errno = ETIME;
02132 return rc;
02133 # elif !defined (ACE_DISABLE_POSIX_SEM_TIMEOUT_EMULATION)
02134 int result = 0;
02135 bool expired = false;
02136 ACE_Errno_Guard error (errno);
02137
02138 ACE_PTHREAD_CLEANUP_PUSH (&s->lock_);
02139
02140 if (ACE_OS::mutex_lock (&s->lock_) != 0)
02141 result = -2;
02142 else
02143 {
02144 bool finished = true;
02145 do
02146 {
02147 result = ACE_OS::sema_trywait (s);
02148 if (result == -1 && errno == EAGAIN)
02149 expired = ACE_OS::gettimeofday () > tv;
02150 else
02151 expired = false;
02152
02153 finished = result != -1 || expired ||
02154 (result == -1 && errno != EAGAIN);
02155 if (!finished)
02156 {
02157 if (ACE_OS::cond_timedwait (&s->count_nonzero_,
02158 &s->lock_,
02159 &tv) == -1)
02160 {
02161 error = errno;
02162 result = -1;
02163 break;
02164 }
02165 }
02166 } while (!finished);
02167
02168 if (expired)
02169 error = ETIME;
02170
02171 # if defined (ACE_LACKS_COND_TIMEDWAIT_RESET)
02172 tv = ACE_OS::gettimeofday ();
02173 # endif
02174 }
02175
02176 if (result != -2)
02177 ACE_OS::mutex_unlock (&s->lock_);
02178 ACE_PTHREAD_CLEANUP_POP (0);
02179 return result < 0 ? -1 : result;
02180 # else
02181 ACE_UNUSED_ARG (s);
02182 ACE_UNUSED_ARG (tv);
02183 ACE_NOTSUP_RETURN (-1);
02184 # endif
02185 # elif defined (ACE_USES_FIFO_SEM)
02186 int rc;
02187 ACE_Time_Value now = ACE_OS::gettimeofday ();
02188
02189 while (tv > now)
02190 {
02191 ACE_Time_Value timeout = tv;
02192 timeout -= now;
02193
02194 ACE_Handle_Set fds_;
02195
02196 fds_.set_bit (s->fd_[0]);
02197 if ((rc = ACE_OS::select (ACE_Handle_Set::MAXSIZE, fds_, 0, 0, timeout)) != 1)
02198 {
02199 if (rc == 0 || errno != EAGAIN)
02200 {
02201 if (rc == 0)
02202 errno = ETIME;
02203 return -1;
02204 }
02205 }
02206
02207
02208 if (rc == 1 && ACE_OS::sema_trywait (s) == 0)
02209 return 0;
02210
02211
02212
02213 now = ACE_OS::gettimeofday ();
02214 }
02215
02216
02217 errno = ETIME;
02218
02219 return -1;
02220 # elif defined (ACE_HAS_THREADS)
02221 # if defined (ACE_HAS_STHREADS)
02222 ACE_UNUSED_ARG (s);
02223 ACE_UNUSED_ARG (tv);
02224 ACE_NOTSUP_RETURN (-1);
02225 # elif defined (ACE_HAS_PTHREADS)
02226 int result = 0;
02227 ACE_Errno_Guard error (errno);
02228
02229 ACE_PTHREAD_CLEANUP_PUSH (&s->lock_);
02230
02231 if (ACE_OS::mutex_lock (&s->lock_) != 0)
02232 result = -1;
02233 else
02234 {
02235
02236
02237 s->waiters_++;
02238
02239
02240 while (s->count_ == 0)
02241 if (ACE_OS::cond_timedwait (&s->count_nonzero_,
02242 &s->lock_,
02243 &tv) == -1)
02244 {
02245 error = errno;
02246 result = -2;
02247 break;
02248 }
02249
02250 --s->waiters_;
02251 }
02252
02253 if (result == 0)
02254 {
02255 # if defined (ACE_LACKS_COND_TIMEDWAIT_RESET)
02256 tv = ACE_OS::gettimeofday ();
02257 # endif
02258 --s->count_;
02259 }
02260
02261 if (result != -1)
02262 ACE_OS::mutex_unlock (&s->lock_);
02263 ACE_PTHREAD_CLEANUP_POP (0);
02264 return result < 0 ? -1 : result;
02265 # elif defined (ACE_HAS_WTHREADS)
02266 # if !defined (ACE_USES_WINCE_SEMA_SIMULATION)
02267 int msec_timeout;
02268
02269 if (tv == ACE_Time_Value::zero)
02270 msec_timeout = 0;
02271 else
02272 {
02273
02274
02275
02276 ACE_Time_Value relative_time (tv - ACE_OS::gettimeofday ());
02277
02278
02279
02280 if (relative_time < ACE_Time_Value::zero)
02281 msec_timeout = 0;
02282 else
02283 msec_timeout = relative_time.msec ();
02284 }
02285
02286 switch (::WaitForSingleObject (*s, msec_timeout))
02287 {
02288 case WAIT_OBJECT_0:
02289 tv = ACE_OS::gettimeofday ();
02290 return 0;
02291 case WAIT_TIMEOUT:
02292 errno = ETIME;
02293 return -1;
02294 default:
02295
02296 ACE_OS::set_errno_to_last_error ();
02297 return -1;
02298 }
02299
02300 # else
02301
02302
02303
02304
02305
02306
02307
02308
02309
02310
02311 ACE_Time_Value end_time = tv;
02312 if (tv == ACE_Time_Value::zero)
02313 end_time = ACE_OS::gettimeofday ();
02314 ACE_Time_Value relative_time = end_time - ACE_OS::gettimeofday ();
02315 int result = -1;
02316
02317
02318
02319
02320 while (relative_time >= ACE_Time_Value::zero)
02321 {
02322
02323 switch (::WaitForSingleObject (s->count_nonzero_, relative_time.msec ()))
02324 {
02325 case WAIT_OBJECT_0:
02326 ACE_OS::thread_mutex_lock (&s->lock_);
02327
02328
02329
02330
02331 if (::WaitForSingleObject (s->count_nonzero_, 0) == WAIT_OBJECT_0)
02332 {
02333
02334
02335 s->count_--;
02336 if (s->count_ <= 0)
02337 ACE_OS::event_reset (&s->count_nonzero_);
02338 result = 0;
02339 }
02340
02341 ACE_OS::thread_mutex_unlock (&s->lock_);
02342
02343
02344 if (result == 0)
02345 {
02346 tv = ACE_OS::gettimeofday ();
02347 return 0;
02348 }
02349 break;
02350
02351
02352 case WAIT_TIMEOUT:
02353 errno = ETIME;
02354 return -1;
02355
02356
02357 default:
02358 ACE_OS::set_errno_to_last_error ();
02359
02360 return -1;
02361 };
02362
02363
02364
02365 relative_time = end_time - ACE_OS::gettimeofday ();
02366 }
02367
02368
02369 errno = ETIME;
02370 return -1;
02371 # endif
02372 # elif defined (ACE_VXWORKS)
02373
02374
02375
02376 ACE_Time_Value relative_time (tv - ACE_OS::gettimeofday ());
02377
02378 int ticks_per_sec = ::sysClkRateGet ();
02379
02380 int ticks = relative_time.sec () * ticks_per_sec +
02381 relative_time.usec () * ticks_per_sec / ACE_ONE_SECOND_IN_USECS;
02382 if (::semTake (s->sema_, ticks) == ERROR)
02383 {
02384 if (errno == S_objLib_OBJ_TIMEOUT)
02385
02386
02387 errno = ETIME;
02388 else if (errno == S_objLib_OBJ_UNAVAILABLE)
02389 errno = EBUSY;
02390 return -1;
02391 }
02392 else
02393 {
02394 tv = ACE_OS::gettimeofday ();
02395 return 0;
02396 }
02397 # endif
02398 # else
02399 ACE_UNUSED_ARG (s);
02400 ACE_UNUSED_ARG (tv);
02401 ACE_NOTSUP_RETURN (-1);
02402 # endif
02403 }
02404
02405 ACE_INLINE int
02406 ACE_OS::sema_wait (ACE_sema_t *s, ACE_Time_Value *tv)
02407 {
02408 return tv == 0 ? ACE_OS::sema_wait (s) : ACE_OS::sema_wait (s, *tv);
02409 }
02410
02411 ACE_INLINE int
02412 ACE_OS::semctl (int int_id, int semnum, int cmd, semun value)
02413 {
02414 ACE_OS_TRACE ("ACE_OS::semctl");
02415 #if defined (ACE_HAS_SYSV_IPC)
02416 ACE_OSCALL_RETURN (::semctl (int_id, semnum, cmd, value), int, -1);
02417 #else
02418 ACE_UNUSED_ARG (int_id);
02419 ACE_UNUSED_ARG (semnum);
02420 ACE_UNUSED_ARG (cmd);
02421 ACE_UNUSED_ARG (value);
02422
02423 ACE_NOTSUP_RETURN (-1);
02424 #endif
02425 }
02426
02427 ACE_INLINE int
02428 ACE_OS::semget (key_t key, int nsems, int flags)
02429 {
02430 ACE_OS_TRACE ("ACE_OS::semget");
02431 #if defined (ACE_HAS_SYSV_IPC)
02432 ACE_OSCALL_RETURN (::semget (key, nsems, flags), int, -1);
02433 #else
02434 ACE_UNUSED_ARG (key);
02435 ACE_UNUSED_ARG (nsems);
02436 ACE_UNUSED_ARG (flags);
02437
02438 ACE_NOTSUP_RETURN (-1);
02439 #endif
02440 }
02441
02442 ACE_INLINE int
02443 ACE_OS::semop (int int_id, struct sembuf *sops, size_t nsops)
02444 {
02445 ACE_OS_TRACE ("ACE_OS::semop");
02446 #if defined (ACE_HAS_SYSV_IPC)
02447 ACE_OSCALL_RETURN (::semop (int_id, sops, nsops), int, -1);
02448 #else
02449 ACE_UNUSED_ARG (int_id);
02450 ACE_UNUSED_ARG (sops);
02451 ACE_UNUSED_ARG (nsops);
02452
02453 ACE_NOTSUP_RETURN (-1);
02454 #endif
02455 }
02456
02457 ACE_INLINE int
02458 ACE_OS::sigtimedwait (const sigset_t *sset,
02459 siginfo_t *info,
02460 const ACE_Time_Value *timeout)
02461 {
02462 ACE_OS_TRACE ("ACE_OS::sigtimedwait");
02463 #if defined (ACE_HAS_SIGTIMEDWAIT)
02464 timespec_t ts;
02465 timespec_t *tsp = 0;
02466
02467 if (timeout != 0)
02468 {
02469 ts = *timeout;
02470 tsp = &ts;
02471 }
02472
02473 ACE_OSCALL_RETURN (::sigtimedwait (sset, info, tsp),
02474 int, -1);
02475 #else
02476 ACE_UNUSED_ARG (sset);
02477 ACE_UNUSED_ARG (info);
02478 ACE_UNUSED_ARG (timeout);
02479 ACE_NOTSUP_RETURN (-1);
02480 #endif
02481 }
02482
02483 ACE_INLINE int
02484 ACE_OS::sigwait (sigset_t *sset, int *sig)
02485 {
02486 ACE_OS_TRACE ("ACE_OS::sigwait");
02487 int local_sig;
02488 if (sig == 0)
02489 sig = &local_sig;
02490 #if defined (ACE_HAS_THREADS)
02491 # if (defined (__FreeBSD__) && (__FreeBSD__ < 3))
02492 ACE_UNUSED_ARG (sset);
02493 ACE_NOTSUP_RETURN (-1);
02494 # elif defined (ACE_HAS_STHREADS)
02495 # if (_POSIX_C_SOURCE - 0 >= 199506L) || defined (_POSIX_PTHREAD_SEMANTICS)
02496 errno = ::sigwait (sset, sig);
02497 return errno == 0 ? *sig : -1;
02498 #else
02499 *sig = ::sigwait (sset);
02500 return *sig;
02501 #endif
02502 # elif defined (ACE_HAS_PTHREADS)
02503
02504 # if defined (DIGITAL_UNIX) && defined (__DECCXX_VER)
02505
02506
02507
02508
02509 errno = ::_Psigwait (sset, sig);
02510 return errno == 0 ? *sig : -1;
02511 # else
02512 # if defined (CYGWIN32)
02513
02514 ACE_UNUSED_ARG (sset);
02515 ACE_NOTSUP_RETURN (-1);
02516 # elif defined (ACE_TANDEM_T1248_PTHREADS)
02517 errno = ::spt_sigwait (sset, sig);
02518 return errno == 0 ? *sig : -1;
02519 # else
02520 errno = ::sigwait (sset, sig);
02521 return errno == 0 ? *sig : -1;
02522 # endif
02523 # endif
02524 # elif defined (ACE_HAS_WTHREADS)
02525 ACE_UNUSED_ARG (sset);
02526 ACE_NOTSUP_RETURN (-1);
02527 # elif defined (ACE_VXWORKS)
02528
02529
02530
02531 *sig = ::sigtimedwait (sset, 0, 0);
02532 return *sig;
02533 # endif
02534 #else
02535 ACE_UNUSED_ARG (sset);
02536 ACE_UNUSED_ARG (sig);
02537 ACE_NOTSUP_RETURN (-1);
02538 #endif
02539 }
02540
02541 ACE_INLINE int
02542 ACE_OS::sigwaitinfo (const sigset_t *sset,
02543 siginfo_t *info)
02544 {
02545 ACE_OS_TRACE ("ACE_OS::sigwaitinfo");
02546
02547
02548
02549 #if defined (ACE_HAS_SIGTIMEDWAIT)
02550 ACE_OSCALL_RETURN (::sigwaitinfo (sset, info), int, -1);
02551 #else
02552 ACE_UNUSED_ARG (sset);
02553 ACE_UNUSED_ARG (info);
02554 ACE_NOTSUP_RETURN (-1);
02555 #endif
02556 }
02557
02558 ACE_INLINE int
02559 ACE_OS::thr_cancel (ACE_thread_t thr_id)
02560 {
02561 ACE_OS_TRACE ("ACE_OS::thr_cancel");
02562 #if defined (ACE_HAS_THREADS)
02563 # if defined (ACE_HAS_PTHREADS) && !defined (ACE_LACKS_PTHREAD_CANCEL)
02564 int result;
02565 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_cancel (thr_id),
02566 result),
02567 int, -1);
02568 # elif defined (ACE_HAS_VXTHREADS)
02569 ACE_OSCALL_RETURN (::taskDelete (thr_id), int, -1);
02570 # else
02571 ACE_UNUSED_ARG (thr_id);
02572 ACE_NOTSUP_RETURN (-1);
02573 # endif
02574 #else
02575 ACE_UNUSED_ARG (thr_id);
02576 ACE_NOTSUP_RETURN (-1);
02577 #endif
02578 }
02579
02580 ACE_INLINE int
02581 ACE_OS::thr_cmp (ACE_hthread_t t1, ACE_hthread_t t2)
02582 {
02583 #if defined (ACE_HAS_PTHREADS)
02584 # if defined (pthread_equal)
02585
02586 return pthread_equal (t1, t2);
02587 # else
02588 return pthread_equal (t1, t2);
02589 # endif
02590 #else
02591
02592
02593 return t1 == t2;
02594 #endif
02595 }
02596
02597 ACE_INLINE int
02598 ACE_OS::thr_continue (ACE_hthread_t target_thread)
02599 {
02600 ACE_OS_TRACE ("ACE_OS::thr_continue");
02601 #if defined (ACE_HAS_THREADS)
02602 # if defined (ACE_HAS_STHREADS)
02603 int result;
02604 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_continue (target_thread), result), int, -1);
02605 # elif defined (ACE_HAS_PTHREADS)
02606 # if defined (ACE_HAS_PTHREAD_CONTINUE)
02607 int result;
02608 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_continue (target_thread),
02609 result),
02610 int, -1);
02611 # elif defined (ACE_HAS_PTHREAD_CONTINUE_NP)
02612 int result;
02613 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_continue_np (target_thread),
02614 result),
02615 int, -1);
02616 # elif defined (ACE_HAS_PTHREAD_RESUME_NP)
02617 int result;
02618 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_resume_np (target_thread),
02619 result),
02620 int, -1);
02621 # else
02622 ACE_UNUSED_ARG (target_thread);
02623 ACE_NOTSUP_RETURN (-1);
02624 # endif
02625 # elif defined (ACE_HAS_WTHREADS)
02626 DWORD result = ::ResumeThread (target_thread);
02627 if (result == ACE_SYSCALL_FAILED)
02628 ACE_FAIL_RETURN (-1);
02629 else
02630 return 0;
02631 # elif defined (ACE_HAS_VXTHREADS)
02632 ACE_OSCALL_RETURN (::taskResume (target_thread), int, -1);
02633 # endif
02634 #else
02635 ACE_UNUSED_ARG (target_thread);
02636 ACE_NOTSUP_RETURN (-1);
02637 #endif
02638 }
02639
02640 ACE_INLINE int
02641 ACE_OS::thr_getconcurrency (void)
02642 {
02643 ACE_OS_TRACE ("ACE_OS::thr_getconcurrency");
02644 #if defined (ACE_HAS_THREADS)
02645 # if defined (ACE_HAS_STHREADS)
02646 return ::thr_getconcurrency ();
02647 # elif defined (ACE_HAS_PTHREADS) && defined (ACE_HAS_PTHREAD_GETCONCURRENCY)
02648 return pthread_getconcurrency ();
02649 # else
02650 ACE_NOTSUP_RETURN (-1);
02651 # endif
02652 #else
02653 ACE_NOTSUP_RETURN (-1);
02654 #endif
02655 }
02656
02657 ACE_INLINE int
02658 ACE_OS::thr_getprio (ACE_hthread_t ht_id, int &priority, int &policy)
02659 {
02660 ACE_OS_TRACE ("ACE_OS::thr_getprio");
02661 ACE_UNUSED_ARG (policy);
02662 #if defined (ACE_HAS_THREADS)
02663 # if (defined (ACE_HAS_PTHREADS) && \
02664 (!defined (ACE_LACKS_SETSCHED) || defined (ACE_HAS_PTHREAD_SCHEDPARAM)))
02665
02666 struct sched_param param;
02667 int result;
02668
02669 ACE_OSCALL (ACE_ADAPT_RETVAL (pthread_getschedparam (ht_id, &policy, ¶m),
02670 result), int,
02671 -1, result);
02672 priority = param.sched_priority;
02673 return result;
02674 # elif defined (ACE_HAS_STHREADS)
02675 int result;
02676 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_getprio (ht_id, &priority), result), int, -1);
02677 # elif defined (ACE_HAS_WTHREADS)
02678 ACE_Errno_Guard error (errno);
02679
02680 # if defined (ACE_HAS_WINCE) && !defined (ACE_LACKS_CE_THREAD_PRIORITY)
02681 priority = ::CeGetThreadPriority (ht_id);
02682 # else
02683 priority = ::GetThreadPriority (ht_id);
02684 # endif
02685
02686 # if defined (ACE_HAS_PHARLAP)
02687 # if defined (ACE_PHARLAP_LABVIEW_RT)
02688 policy = ACE_SCHED_FIFO;
02689 # else
02690 DWORD timeslice = ::EtsGetTimeSlice ();
02691 policy = timeslice == 0 ? ACE_SCHED_OTHER : ACE_SCHED_FIFO;
02692 # endif
02693 # elif !defined (ACE_HAS_WINCE)
02694 DWORD priority_class = ::GetPriorityClass (::GetCurrentProcess ());
02695 if (priority_class == 0 && (error = ::GetLastError ()) != NO_ERROR)
02696 ACE_FAIL_RETURN (-1);
02697
02698 policy =
02699 (priority_class ==
02700 REALTIME_PRIORITY_CLASS) ? ACE_SCHED_FIFO : ACE_SCHED_OTHER;
02701 # endif
02702
02703 return 0;
02704 # elif defined (ACE_HAS_VXTHREADS)
02705 ACE_OSCALL_RETURN (::taskPriorityGet (ht_id, &priority), int, -1);
02706 # else
02707 ACE_UNUSED_ARG (ht_id);
02708 ACE_UNUSED_ARG (priority);
02709 ACE_NOTSUP_RETURN (-1);
02710 # endif
02711 #else
02712 ACE_UNUSED_ARG (ht_id);
02713 ACE_UNUSED_ARG (priority);
02714 ACE_NOTSUP_RETURN (-1);
02715 #endif
02716 }
02717
02718 ACE_INLINE int
02719 ACE_OS::thr_getprio (ACE_hthread_t ht_id, int &priority)
02720 {
02721 ACE_OS_TRACE ("ACE_OS::thr_getprio");
02722 int policy = 0;
02723 return ACE_OS::thr_getprio (ht_id, priority, policy);
02724 }
02725
02726 #if defined (ACE_HAS_THREAD_SPECIFIC_STORAGE)
02727 ACE_INLINE int
02728 ACE_OS::thr_getspecific_native (ACE_OS_thread_key_t key, void **data)
02729 {
02730
02731 # if defined (ACE_HAS_PTHREADS)
02732 *data = pthread_getspecific (key);
02733 return 0;
02734 # elif defined (ACE_HAS_STHREADS)
02735 int result;
02736 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_getspecific (key, data), result), int, -1);
02737 # elif defined (ACE_HAS_WTHREADS)
02738 *data = ::TlsGetValue (key);
02739 if (*data == 0 && ::GetLastError () != NO_ERROR)
02740 {
02741 ACE_OS::set_errno_to_last_error ();
02742 return -1;
02743 }
02744 else
02745 return 0;
02746 # else
02747 ACE_UNUSED_ARG (key);
02748 ACE_UNUSED_ARG (data);
02749 ACE_NOTSUP_RETURN (-1);
02750 # endif
02751 }
02752 #endif
02753
02754 ACE_INLINE int
02755 ACE_OS::thr_getspecific (ACE_thread_key_t key, void **data)
02756 {
02757
02758 #if defined (ACE_HAS_THREADS)
02759 # if defined (ACE_HAS_TSS_EMULATION)
02760 if (ACE_TSS_Emulation::is_key (key) == 0)
02761 {
02762 errno = EINVAL;
02763 data = 0;
02764 return -1;
02765 }
02766 else
02767 {
02768 *data = ACE_TSS_Emulation::ts_object (key);
02769 return 0;
02770 }
02771 # elif defined (ACE_HAS_THREAD_SPECIFIC_STORAGE)
02772 return ACE_OS::thr_getspecific_native (key, data);
02773 #else
02774 ACE_UNUSED_ARG (key);
02775 ACE_UNUSED_ARG (data);
02776 ACE_NOTSUP_RETURN (-1);
02777 # endif
02778 #else
02779 ACE_UNUSED_ARG (key);
02780 ACE_UNUSED_ARG (data);
02781 ACE_NOTSUP_RETURN (-1);
02782 #endif
02783 }
02784
02785 #if !defined (ACE_HAS_VXTHREADS)
02786 ACE_INLINE int
02787 ACE_OS::thr_join (ACE_hthread_t thr_handle,
02788 ACE_THR_FUNC_RETURN *status)
02789 {
02790 ACE_OS_TRACE ("ACE_OS::thr_join");
02791 #if defined (ACE_HAS_THREADS)
02792 # if defined (ACE_HAS_STHREADS)
02793 int result;
02794 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_join (thr_handle, 0, status), result),
02795 int, -1);
02796 # elif defined (ACE_HAS_PTHREADS)
02797 int result;
02798 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_join (thr_handle, status), result),
02799 int, -1);
02800 # elif defined (ACE_HAS_WTHREADS)
02801 ACE_THR_FUNC_RETURN local_status = 0;
02802
02803
02804 if (status == 0)
02805 status = &local_status;
02806
02807 if (::WaitForSingleObject (thr_handle, INFINITE) == WAIT_OBJECT_0
02808 && ::GetExitCodeThread (thr_handle, status) != FALSE)
02809 {
02810 ::CloseHandle (thr_handle);
02811 return 0;
02812 }
02813 ACE_FAIL_RETURN (-1);
02814
02815 # else
02816 ACE_UNUSED_ARG (thr_handle);
02817 ACE_UNUSED_ARG (status);
02818 ACE_NOTSUP_RETURN (-1);
02819 # endif
02820 #else
02821 ACE_UNUSED_ARG (thr_handle);
02822 ACE_UNUSED_ARG (status);
02823 ACE_NOTSUP_RETURN (-1);
02824 #endif
02825 }
02826
02827 ACE_INLINE int
02828 ACE_OS::thr_join (ACE_thread_t waiter_id,
02829 ACE_thread_t *thr_id,
02830 ACE_THR_FUNC_RETURN *status)
02831 {
02832 ACE_OS_TRACE ("ACE_OS::thr_join");
02833 #if defined (ACE_HAS_THREADS)
02834 # if defined (ACE_HAS_STHREADS)
02835 int result;
02836 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_join (waiter_id, thr_id, status), result),
02837 int, -1);
02838 # elif defined (ACE_HAS_PTHREADS)
02839 ACE_UNUSED_ARG (thr_id);
02840 int result;
02841 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_join (waiter_id, status), result),
02842 int, -1);
02843 # elif defined (ACE_HAS_WTHREADS)
02844 ACE_UNUSED_ARG (waiter_id);
02845 ACE_UNUSED_ARG (thr_id);
02846 ACE_UNUSED_ARG (status);
02847
02848
02849
02850 ACE_NOTSUP_RETURN (-1);
02851 # endif
02852 #else
02853 ACE_UNUSED_ARG (waiter_id);
02854 ACE_UNUSED_ARG (thr_id);
02855 ACE_UNUSED_ARG (status);
02856 ACE_NOTSUP_RETURN (-1);
02857 #endif
02858 }
02859 #endif
02860
02861 ACE_INLINE int
02862 ACE_OS::thr_kill (ACE_thread_t thr_id, int signum)
02863 {
02864 ACE_OS_TRACE ("ACE_OS::thr_kill");
02865 #if defined (ACE_HAS_THREADS)
02866 # if defined (ACE_HAS_PTHREADS)
02867 # if defined (ACE_LACKS_PTHREAD_KILL)
02868 ACE_UNUSED_ARG (signum);
02869 ACE_UNUSED_ARG (thr_id);
02870 ACE_NOTSUP_RETURN (-1);
02871 # else
02872 int result;
02873 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_kill (thr_id, signum),
02874 result),
02875 int, -1);
02876 # endif
02877 # elif defined (ACE_HAS_STHREADS)
02878 int result;
02879 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_kill (thr_id, signum),
02880 result),
02881 int, -1);
02882 # elif defined (ACE_HAS_VXTHREADS)
02883
02884 ACE_OSCALL_RETURN (::kill (thr_id, signum), int, -1);
02885
02886 # else
02887 ACE_UNUSED_ARG (thr_id);
02888 ACE_UNUSED_ARG (signum);
02889 ACE_NOTSUP_RETURN (-1);
02890 # endif
02891 #else
02892 ACE_UNUSED_ARG (thr_id);
02893 ACE_UNUSED_ARG (signum);
02894 ACE_NOTSUP_RETURN (-1);
02895 #endif
02896 }
02897
02898 ACE_INLINE size_t
02899 ACE_OS::thr_min_stack (void)
02900 {
02901 ACE_OS_TRACE ("ACE_OS::thr_min_stack");
02902 #if defined (ACE_HAS_THREADS)
02903 # if defined (ACE_HAS_STHREADS)
02904 # if defined (ACE_HAS_THR_MINSTACK)
02905
02906 return ::thr_minstack ();
02907 # else
02908 return ::thr_min_stack ();
02909 # endif
02910 # elif defined (ACE_HAS_PTHREADS)
02911 # if defined (_SC_THREAD_STACK_MIN)
02912 return (size_t) ACE_OS::sysconf (_SC_THREAD_STACK_MIN);
02913 # elif defined (PTHREAD_STACK_MIN)
02914 return PTHREAD_STACK_MIN;
02915 # else
02916 ACE_NOTSUP_RETURN (0);
02917 # endif
02918 # elif defined (ACE_HAS_WTHREADS)
02919 ACE_NOTSUP_RETURN (0);
02920 # elif defined (ACE_HAS_VXTHREADS)
02921 TASK_DESC taskDesc;
02922 STATUS status;
02923
02924 ACE_thread_t tid = ACE_OS::thr_self ();
02925
02926 ACE_OSCALL (ACE_ADAPT_RETVAL (::taskInfoGet (tid, &taskDesc),
02927 status),
02928 STATUS, -1, status);
02929 return status == OK ? taskDesc.td_stackSize : 0;
02930 # else
02931 ACE_NOTSUP_RETURN (0);
02932 # endif
02933 #else
02934 ACE_NOTSUP_RETURN (0);
02935 #endif
02936 }
02937
02938 ACE_INLINE ACE_thread_t
02939 ACE_OS::thr_self (void)
02940 {
02941
02942 #if defined (ACE_HAS_THREADS)
02943 # if defined (ACE_HAS_PTHREADS)
02944
02945 return pthread_self ();
02946 # elif defined (ACE_HAS_STHREADS)
02947 ACE_OSCALL_RETURN (::thr_self (), int, -1);
02948 # elif defined (ACE_HAS_WTHREADS)
02949 return ::GetCurrentThreadId ();
02950 # elif defined (ACE_HAS_VXTHREADS)
02951 return ::taskIdSelf ();
02952 # endif
02953 #else
02954 return 1;
02955 #endif
02956 }
02957
02958 ACE_INLINE const char*
02959 ACE_OS::thr_name (void)
02960 {
02961 #if defined (ACE_HAS_THREADS)
02962 #if defined (ACE_HAS_VXTHREADS)
02963 return ::taskName (ACE_OS::thr_self ());
02964 #else
02965 ACE_NOTSUP_RETURN (0);
02966 #endif
02967 #else
02968 ACE_NOTSUP_RETURN (0);
02969 #endif
02970 }
02971
02972 ACE_INLINE void
02973 ACE_OS::thr_self (ACE_hthread_t &self)
02974 {
02975 ACE_OS_TRACE ("ACE_OS::thr_self");
02976 #if defined (ACE_HAS_THREADS)
02977 # if defined (ACE_HAS_PTHREADS)
02978
02979 self = pthread_self ();
02980 # elif defined (ACE_HAS_THREAD_SELF)
02981 self = ::thread_self ();
02982 # elif defined (ACE_HAS_STHREADS)
02983 self = ::thr_self ();
02984 # elif defined (ACE_HAS_WTHREADS)
02985 self = ::GetCurrentThread ();
02986 # elif defined (ACE_HAS_VXTHREADS)
02987 self = ::taskIdSelf ();
02988 # endif
02989 #else
02990 self = 1;
02991 #endif
02992 }
02993
02994 ACE_INLINE int
02995 ACE_OS::thr_setcancelstate (int new_state, int *old_state)
02996 {
02997 ACE_OS_TRACE ("ACE_OS::thr_setcancelstate");
02998 #if defined (ACE_HAS_THREADS)
02999 # if defined (ACE_HAS_PTHREADS) && !defined (ACE_LACKS_PTHREAD_CANCEL)
03000 int result;
03001 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_setcancelstate (new_state,
03002 old_state),
03003 result),
03004 int, -1);
03005 # elif defined (ACE_HAS_STHREADS)
03006 ACE_UNUSED_ARG (new_state);
03007 ACE_UNUSED_ARG (old_state);
03008 ACE_NOTSUP_RETURN (-1);
03009 # elif defined (ACE_HAS_WTHREADS)
03010 ACE_UNUSED_ARG (new_state);
03011 ACE_UNUSED_ARG (old_state);
03012 ACE_NOTSUP_RETURN (-1);
03013 # else
03014 ACE_UNUSED_ARG (new_state);
03015 ACE_UNUSED_ARG (old_state);
03016 ACE_NOTSUP_RETURN (-1);
03017 # endif
03018 #else
03019 ACE_UNUSED_ARG (new_state);
03020 ACE_UNUSED_ARG (old_state);
03021 ACE_NOTSUP_RETURN (-1);
03022 #endif
03023 }
03024
03025 ACE_INLINE int
03026 ACE_OS::thr_setcanceltype (int new_type, int *old_type)
03027 {
03028 ACE_OS_TRACE ("ACE_OS::thr_setcanceltype");
03029 #if defined (ACE_HAS_THREADS)
03030 # if defined (ACE_HAS_PTHREADS) && !defined (ACE_LACKS_PTHREAD_CANCEL)
03031 int result;
03032 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_setcanceltype (new_type,
03033 old_type),
03034 result),
03035 int, -1);
03036 # else
03037 ACE_UNUSED_ARG (new_type);
03038 ACE_UNUSED_ARG (old_type);
03039 ACE_NOTSUP_RETURN (-1);
03040 # endif
03041 #else
03042 ACE_UNUSED_ARG (new_type);
03043 ACE_UNUSED_ARG (old_type);
03044 ACE_NOTSUP_RETURN (-1);
03045 #endif
03046 }
03047
03048 ACE_INLINE int
03049 ACE_OS::thr_setconcurrency (int hint)
03050 {
03051 ACE_OS_TRACE ("ACE_OS::thr_setconcurrency");
03052 #if defined (ACE_HAS_THREADS)
03053 # if defined (ACE_HAS_STHREADS)
03054 int result;
03055 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_setconcurrency (hint),
03056 result),
03057 int, -1);
03058 # elif defined (ACE_HAS_PTHREADS) && defined (ACE_HAS_PTHREAD_SETCONCURRENCY)
03059 int result;
03060 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_setconcurrency (hint),
03061 result),
03062 int, -1);
03063 # else
03064 ACE_UNUSED_ARG (hint);
03065 ACE_NOTSUP_RETURN (-1);
03066 # endif
03067 #else
03068 ACE_UNUSED_ARG (hint);
03069 ACE_NOTSUP_RETURN (-1);
03070 #endif
03071 }
03072
03073 ACE_INLINE int
03074 ACE_OS::thr_setprio (ACE_hthread_t ht_id, int priority, int policy)
03075 {
03076 ACE_OS_TRACE ("ACE_OS::thr_setprio");
03077 ACE_UNUSED_ARG (policy);
03078 #if defined (ACE_HAS_THREADS)
03079 # if (defined (ACE_HAS_PTHREADS) && \
03080 (!defined (ACE_LACKS_SETSCHED) || defined (ACE_HAS_PTHREAD_SCHEDPARAM)))
03081
03082 int result;
03083 struct sched_param param;
03084 ACE_OS::memset ((void *) ¶m, 0, sizeof param);
03085
03086
03087
03088
03089 if (policy == -1)
03090 {
03091 ACE_OSCALL (ACE_ADAPT_RETVAL (pthread_getschedparam (ht_id, &policy, ¶m),
03092 result),
03093 int, -1, result);
03094 if (result == -1)
03095 return result;
03096 }
03097
03098 param.sched_priority = priority;
03099
03100 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_setschedparam (ht_id,
03101 policy,
03102 ¶m),
03103 result),
03104 int, -1);
03105 # elif defined (ACE_HAS_STHREADS)
03106 int result;
03107 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_setprio (ht_id, priority),
03108 result),
03109 int, -1);
03110 # elif defined (ACE_HAS_WTHREADS)
03111
03112 # if defined (ACE_HAS_WINCE) && !defined (ACE_LACKS_CE_THREAD_PRIORITY)
03113 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::CeSetThreadPriority (ht_id, priority),
03114 ace_result_),
03115 int, -1);
03116 # else
03117 ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::SetThreadPriority (ht_id, priority),
03118 ace_result_),
03119 int, -1);
03120 # endif
03121
03122 # elif defined (ACE_HAS_VXTHREADS)
03123 ACE_OSCALL_RETURN (::taskPrioritySet (ht_id, priority), int, -1);
03124 # else
03125
03126 ACE_UNUSED_ARG (ht_id);
03127 ACE_UNUSED_ARG (priority);
03128 ACE_NOTSUP_RETURN (-1);
03129 # endif
03130 #else
03131 ACE_UNUSED_ARG (ht_id);
03132 ACE_UNUSED_ARG (priority);
03133 ACE_NOTSUP_RETURN (-1);
03134 #endif
03135 }
03136
03137 ACE_INLINE int
03138 ACE_OS::thr_sigsetmask (int how,
03139 const sigset_t *nsm,
03140 sigset_t *osm)
03141 {
03142 ACE_OS_TRACE ("ACE_OS::thr_sigsetmask");
03143 #if defined (ACE_HAS_THREADS)
03144 # if defined (ACE_LACKS_PTHREAD_THR_SIGSETMASK)
03145
03146 ACE_UNUSED_ARG (osm);
03147 ACE_UNUSED_ARG (nsm);
03148 ACE_UNUSED_ARG (how);
03149
03150 ACE_NOTSUP_RETURN (-1);
03151 # elif defined (ACE_HAS_SIGTHREADMASK)
03152 int result;
03153 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::sigthreadmask (how, nsm, osm),
03154 result), int, -1);
03155 # elif defined (ACE_HAS_STHREADS)
03156 int result;
03157 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_sigsetmask (how, nsm, osm),
03158 result),
03159 int, -1);
03160 # elif defined (ACE_HAS_PTHREADS)
03161 # if !defined (ACE_LACKS_PTHREAD_SIGMASK)
03162 int result;
03163
03164 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::pthread_sigmask (how, nsm, osm),
03165 result), int, -1);
03166
03167 # endif
03168
03169 #if 0
03170
03171
03172 int result;
03173 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_sigaction (how, nsm, osm),
03174 result), int, -1);
03175 #endif
03176
03177 # elif defined (ACE_HAS_WTHREADS)
03178 ACE_UNUSED_ARG (osm);
03179 ACE_UNUSED_ARG (nsm);
03180 ACE_UNUSED_ARG (how);
03181
03182 ACE_NOTSUP_RETURN (-1);
03183 # elif defined (ACE_VXWORKS)
03184 int old_mask = 0;
03185 switch (how)
03186 {
03187 case SIG_BLOCK:
03188 case SIG_UNBLOCK:
03189 {
03190
03191 old_mask = ::sigsetmask (*nsm);
03192
03193
03194 ::sigsetmask (how == SIG_BLOCK ? (old_mask |= *nsm) : (old_mask &= ~*nsm));
03195 if (osm)
03196 *osm = old_mask;
03197 break;
03198 }
03199 case SIG_SETMASK:
03200 old_mask = ::sigsetmask (*nsm);
03201 if (osm)
03202 *osm = old_mask;
03203 break;
03204 default:
03205 return -1;
03206 }
03207
03208 return 0;
03209 # else
03210 ACE_UNUSED_ARG (how);
03211 ACE_UNUSED_ARG (nsm);
03212 ACE_UNUSED_ARG (osm);
03213 ACE_NOTSUP_RETURN (-1);
03214 # endif
03215 #else
03216 ACE_UNUSED_ARG (how);
03217 ACE_UNUSED_ARG (nsm);
03218 ACE_UNUSED_ARG (osm);
03219 ACE_NOTSUP_RETURN (-1);
03220 #endif
03221 }
03222
03223 ACE_INLINE int
03224 ACE_OS::thr_suspend (ACE_hthread_t target_thread)
03225 {
03226 ACE_OS_TRACE ("ACE_OS::thr_suspend");
03227 #if defined (ACE_HAS_THREADS)
03228 # if defined (ACE_HAS_STHREADS)
03229 int result;
03230 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (::thr_suspend (target_thread), result), int, -1);
03231 # elif defined (ACE_HAS_PTHREADS)
03232 # if defined (ACE_HAS_PTHREAD_SUSPEND)
03233 int result;
03234 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_suspend (target_thread),
03235 result),
03236 int, -1);
03237 # elif defined (ACE_HAS_PTHREAD_SUSPEND_NP)
03238 int result;
03239 ACE_OSCALL_RETURN (ACE_ADAPT_RETVAL (pthread_suspend_np (target_thread),
03240 result),
03241 int, -1);
03242 # else
03243 ACE_UNUSED_ARG (target_thread);
03244 ACE_NOTSUP_RETURN (-1);
03245 # endif
03246 # elif defined (ACE_HAS_WTHREADS)
03247 if (::SuspendThread (target_thread) != ACE_SYSCALL_FAILED)
03248 return 0;
03249 else
03250 ACE_FAIL_RETURN (-1);
03251
03252 # elif defined (ACE_HAS_VXTHREADS)
03253 ACE_OSCALL_RETURN (::taskSuspend (target_thread), int, -1);
03254 # endif
03255 #else
03256 ACE_UNUSED_ARG (target_thread);
03257 ACE_NOTSUP_RETURN (-1);
03258 #endif
03259 }
03260
03261 ACE_INLINE void
03262 ACE_OS::thr_testcancel (void)
03263 {
03264 ACE_OS_TRACE ("ACE_OS::thr_testcancel");
03265 #if defined (ACE_HAS_THREADS)
03266 # if defined (ACE_HAS_PTHREADS) && !defined (ACE_LACKS_PTHREAD_CANCEL)
03267 pthread_testcancel ();
03268 # elif defined (ACE_HAS_STHREADS)
03269 # elif defined (ACE_HAS_WTHREADS)
03270 # elif defined (ACE_HAS_VXTHREADS)
03271 # else
03272
03273 # endif
03274 #else
03275 #endif
03276 }
03277
03278 ACE_INLINE void
03279 ACE_OS::thr_yield (void)
03280 {
03281 ACE_OS_TRACE ("ACE_OS::thr_yield");
03282 #if defined (ACE_HAS_THREADS)
03283 # if defined (ACE_HAS_PTHREADS)
03284 ::sched_yield ();
03285 # elif defined (ACE_HAS_STHREADS)
03286 ::thr_yield ();
03287 # elif defined (ACE_HAS_WTHREADS)
03288 ::Sleep (0);
03289 # elif defined (ACE_HAS_VXTHREADS)
03290
03291
03292
03293
03294 ::taskDelay (0);
03295 # endif
03296 #else
03297 ;
03298 #endif
03299 }
03300
03301 ACE_INLINE int
03302 ACE_OS::thread_mutex_destroy (ACE_thread_mutex_t *m)
03303 {
03304 ACE_OS_TRACE ("ACE_OS::thread_mutex_destroy");
03305 #if defined (ACE_HAS_THREADS)
03306 # if defined (ACE_HAS_WTHREADS)
03307 ::DeleteCriticalSection (m);
03308 return 0;
03309 # else
03310 return ACE_OS::mutex_destroy (m);
03311 # endif
03312 #else
03313 ACE_UNUSED_ARG (m);
03314 ACE_NOTSUP_RETURN (-1);
03315
03316 #endif
03317 }
03318
03319 ACE_INLINE int
03320 ACE_OS::thread_mutex_init (ACE_thread_mutex_t *m,
03321 int lock_type,
03322 const char *name,
03323 ACE_mutexattr_t *arg)
03324 {
03325
03326 #if defined (ACE_HAS_THREADS)
03327 # if defined (ACE_HAS_WTHREADS)
03328 ACE_UNUSED_ARG (lock_type);
03329 ACE_UNUSED_ARG (name);
03330 ACE_UNUSED_ARG (arg);
03331
03332 ACE_SEH_TRY
03333 {
03334 ::InitializeCriticalSection (m);
03335 }
03336 ACE_SEH_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
03337 {
03338 errno = ENOMEM;
03339 return -1;
03340 }
03341 return 0;
03342
03343 # elif defined (ACE_HAS_STHREADS) || defined (ACE_HAS_PTHREADS)
03344
03345 return ACE_OS::mutex_init (m, USYNC_THREAD, name, arg, 0, lock_type);
03346 # elif defined (ACE_HAS_VXTHREADS)
03347 return mutex_init (m, lock_type, name, arg);
03348
03349 # endif
03350
03351 #else
03352 ACE_UNUSED_ARG (m);
03353 ACE_UNUSED_ARG (lock_type);
03354 ACE_UNUSED_ARG (name);
03355 ACE_UNUSED_ARG (arg);
03356 ACE_NOTSUP_RETURN (-1);
03357
03358 #endif
03359 }
03360
03361 #if defined (ACE_HAS_WCHAR)
03362 ACE_INLINE int
03363 ACE_OS::thread_mutex_init (ACE_thread_mutex_t *m,
03364 int lock_type,
03365 const wchar_t *name,
03366 ACE_mutexattr_t *arg)
03367 {
03368
03369 #if defined (ACE_HAS_THREADS)
03370 # if defined (ACE_HAS_WTHREADS)
03371 ACE_UNUSED_ARG (lock_type);
03372 ACE_UNUSED_ARG (name);
03373 ACE_UNUSED_ARG (arg);
03374
03375 ACE_SEH_TRY
03376 {
03377 ::InitializeCriticalSection (m);
03378 }
03379 ACE_SEH_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
03380 {
03381 errno = ENOMEM;
03382 return -1;
03383 }
03384 return 0;
03385
03386 # elif defined (ACE_HAS_STHREADS) || defined (ACE_HAS_PTHREADS)
03387
03388 return ACE_OS::mutex_init (m, USYNC_THREAD, name, arg, 0, lock_type);
03389 # elif defined (ACE_HAS_VXTHREADS)
03390 return mutex_init (m, lock_type, name, arg);
03391 # endif
03392 #else
03393 ACE_UNUSED_ARG (m);
03394 ACE_UNUSED_ARG (lock_type);
03395 ACE_UNUSED_ARG (name);
03396 ACE_UNUSED_ARG (arg);
03397 ACE_NOTSUP_RETURN (-1);
03398
03399 #endif
03400 }
03401 #endif
03402
03403 ACE_INLINE int
03404 ACE_OS::thread_mutex_lock (ACE_thread_mutex_t *m)
03405 {
03406
03407 #if defined (ACE_HAS_THREADS)
03408 # if defined (ACE_HAS_WTHREADS)
03409 ::EnterCriticalSection (m);
03410 return 0;
03411 # else
03412 return ACE_OS::mutex_lock (m);
03413 # endif
03414 #else
03415 ACE_UNUSED_ARG (m);
03416 ACE_NOTSUP_RETURN (-1);
03417 #endif
03418 }
03419
03420 ACE_INLINE int
03421 ACE_OS::thread_mutex_lock (ACE_thread_mutex_t *m,
03422 const ACE_Time_Value &timeout)
03423 {
03424
03425
03426
03427
03428
03429
03430
03431
03432
03433
03434 #if defined (ACE_HAS_THREADS) && !defined (ACE_HAS_WTHREADS)
03435 return ACE_OS::mutex_lock (m, timeout);
03436 #else
03437 ACE_UNUSED_ARG (m);
03438 ACE_UNUSED_ARG (timeout);
03439 ACE_NOTSUP_RETURN (-1);
03440 #endif
03441 }
03442
03443 ACE_INLINE int
03444 ACE_OS::thread_mutex_lock (ACE_thread_mutex_t *m,
03445 const ACE_Time_Value *timeout)
03446 {
03447 return timeout == 0
03448 ? ACE_OS::thread_mutex_lock (m)
03449 : ACE_OS::thread_mutex_lock (m, *timeout);
03450 }
03451
03452 ACE_INLINE int
03453 ACE_OS::thread_mutex_trylock (ACE_thread_mutex_t *m)
03454 {
03455 ACE_OS_TRACE ("ACE_OS::thread_mutex_trylock");
03456
03457 #if defined (ACE_HAS_THREADS)
03458 # if defined (ACE_HAS_WTHREADS)
03459 # if defined (ACE_HAS_WIN32_TRYLOCK)
03460 BOOL result = ::TryEnterCriticalSection (m);
03461 if (result == TRUE)
03462 return 0;
03463 else
03464 {
03465 errno = EBUSY;
03466 return -1;
03467 }
03468 # else
03469 ACE_UNUSED_ARG (m);
03470 ACE_NOTSUP_RETURN (-1);
03471 # endif
03472 # elif defined (ACE_HAS_STHREADS) || defined (ACE_HAS_PTHREADS) || defined (ACE_VXWORKS)
03473 return ACE_OS::mutex_trylock (m);
03474 #endif
03475
03476 #else
03477 ACE_UNUSED_ARG (m);
03478 ACE_NOTSUP_RETURN (-1);
03479 #endif
03480 }
03481
03482 ACE_INLINE int
03483 ACE_OS::thread_mutex_unlock (ACE_thread_mutex_t *m)
03484 {
03485 ACE_OS_TRACE ("ACE_OS::thread_mutex_unlock");
03486 #if defined (ACE_HAS_THREADS)
03487 # if defined (ACE_HAS_WTHREADS)
03488 ::LeaveCriticalSection (m);
03489 return 0;
03490 # else
03491 return ACE_OS::mutex_unlock (m);
03492 # endif
03493 #else
03494 ACE_UNUSED_ARG (m);
03495 ACE_NOTSUP_RETURN (-1);
03496 #endif
03497 }
03498
03499
03500
03501 # if defined (ACE_IS_SPLITTING)
03502 # define ACE_SPECIAL_INLINE
03503 # else
03504 # define ACE_SPECIAL_INLINE ACE_INLINE
03505
03506 # endif
03507
03508 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
03509
03510 ACE_INLINE
03511 int
03512 ACE_OS_Thread_Mutex_Guard::acquire (void)
03513 {
03514 return owner_ = ACE_OS::thread_mutex_lock (&lock_);
03515 }
03516
03517 ACE_INLINE
03518 int
03519 ACE_OS_Thread_Mutex_Guard::release (void)
03520 {
03521 if (owner_ == -1)
03522 return 0;
03523 else
03524 {
03525 owner_ = -1;
03526 return ACE_OS::thread_mutex_unlock (&lock_);
03527 }
03528 }
03529
03530 ACE_INLINE
03531 ACE_OS_Thread_Mutex_Guard::ACE_OS_Thread_Mutex_Guard (ACE_thread_mutex_t &m)
03532 : lock_ (m), owner_ (-1)
03533 {
03534 if (!ACE_OS_Object_Manager::starting_up ())
03535 acquire ();
03536 }
03537
03538 ACE_INLINE
03539 ACE_OS_Thread_Mutex_Guard::~ACE_OS_Thread_Mutex_Guard ()
03540 {
03541 release ();
03542 }
03543
03544
03545
03546 ACE_INLINE
03547 int
03548 ACE_OS_Recursive_Thread_Mutex_Guard::acquire (void)
03549 {
03550 return owner_ = ACE_OS::recursive_mutex_lock (&lock_);
03551 }
03552
03553 ACE_INLINE
03554 int
03555 ACE_OS_Recursive_Thread_Mutex_Guard::release (void)
03556 {
03557 if (owner_ == -1)
03558 return 0;
03559 else
03560 {
03561 owner_ = -1;
03562 return ACE_OS::recursive_mutex_unlock (&lock_);
03563 }
03564 }
03565
03566 ACE_INLINE
03567 ACE_OS_Recursive_Thread_Mutex_Guard::ACE_OS_Recursive_Thread_Mutex_Guard (
03568 ACE_recursive_thread_mutex_t &m)
03569 : lock_ (m),
03570 owner_ (-1)
03571 {
03572 if (!ACE_OS_Object_Manager::starting_up ())
03573 acquire ();
03574 }
03575
03576 ACE_INLINE
03577 ACE_OS_Recursive_Thread_Mutex_Guard::~ACE_OS_Recursive_Thread_Mutex_Guard ()
03578 {
03579 release ();
03580 }
03581
03582 #endif
03583
03584
03585
03586
03587 ACE_INLINE
03588 ACE_Thread_ID::ACE_Thread_ID (ACE_thread_t thread_id,
03589 ACE_hthread_t thread_handle)
03590 : thread_id_ (thread_id),
03591 thread_handle_ (thread_handle)
03592 {
03593 }
03594
03595 ACE_INLINE
03596 ACE_Thread_ID::ACE_Thread_ID (const ACE_Thread_ID &id)
03597 : thread_id_ (id.thread_id_),
03598 thread_handle_ (id.thread_handle_)
03599 {
03600 }
03601
03602 ACE_INLINE
03603 ACE_Thread_ID::ACE_Thread_ID (void)
03604 : thread_id_ (ACE_OS::thr_self ())
03605 {
03606 ACE_OS::thr_self (thread_handle_);
03607 }
03608
03609 ACE_INLINE
03610 ACE_thread_t
03611 ACE_Thread_ID::id (void) const
03612 {
03613 return this->thread_id_;
03614 }
03615
03616 ACE_INLINE void
03617 ACE_Thread_ID::id (ACE_thread_t thread_id)
03618 {
03619 this->thread_id_ = thread_id;
03620 }
03621
03622 ACE_INLINE ACE_hthread_t
03623 ACE_Thread_ID::handle (void) const
03624 {
03625 return this->thread_handle_;
03626 }
03627
03628 ACE_INLINE void
03629 ACE_Thread_ID::handle (ACE_hthread_t thread_handle)
03630 {
03631 this->thread_handle_ = thread_handle;
03632 }
03633
03634 ACE_INLINE bool
03635 ACE_Thread_ID::operator== (const ACE_Thread_ID &rhs) const
03636 {
03637 return
03638 ACE_OS::thr_cmp (this->thread_handle_, rhs.thread_handle_)
03639 && ACE_OS::thr_equal (this->thread_id_, rhs.thread_id_);
03640 }
03641
03642 ACE_INLINE bool
03643 ACE_Thread_ID::operator!= (const ACE_Thread_ID &rhs) const
03644 {
03645 return !(*this == rhs);
03646 }
03647
03648 ACE_END_VERSIONED_NAMESPACE_DECL