probe_thread/libdasync.c

   1 /*
   2  *  DA probe
   3  *
   4  * Copyright 2000 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:
   7  *
   8  * Woojin Jung <woojin2.jung@samsung.com>
   9  * Jaewon Lim <jaewon81.lim@samsung.com>
  10  * Juyoung Kim <j0.kim@samsung.com>
  11  * Anastasia Lyupa <a.lyupa@samsung.com>
  12  *
  13  * This library is free software; you can redistribute it and/or modify it under
  14  * the terms of the GNU Lesser General Public License as published by the
  15  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  16  * any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  19  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  20  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  21  * License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public License
  24  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  25  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  26  *
  27  * Contributors:
  28  * - S-Core Co., Ltd
  29  * - Samsung RnD Institute Russia
  30  *
  31  */
  32
  33 #include <pthread.h>
  34 #include <time.h>
  35 #include <errno.h>
  36 #include "daprobe.h"
  37 #include "probeinfo.h"
  38 #include "dahelper.h"
  39 #include "da_sync.h"
  40
  41 #include "binproto.h"
  42
  43 static enum DaOptions _sopt = OPT_THREAD;
  44
  45 int pthread_mutex_init(pthread_mutex_t *mutex,
  46                 const pthread_mutexattr_t *attr) {
  47         static int (*pthread_mutex_initp)(pthread_mutex_t *mutex,
  48                         const pthread_mutexattr_t *attr);
  49
  50         BEFORE_ORIGINAL_SYNC(pthread_mutex_init, LIBPTHREAD);
  51
  52         ret = pthread_mutex_initp(mutex, attr);
  53
  54         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutex_init,
  55                                  ret, mutex, SYNC_PTHREAD_MUTEX,
  56                                  SYNC_API_OTHER, "pp", mutex, attr);
  57
  58         return ret;
  59 }
  60
  61 int pthread_mutex_destroy(pthread_mutex_t *mutex) {
  62         static int (*pthread_mutex_destroyp)(pthread_mutex_t *mutex);
  63
  64         BEFORE_ORIGINAL_SYNC(pthread_mutex_destroy, LIBPTHREAD);
  65
  66         ret = pthread_mutex_destroyp(mutex);
  67
  68         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutex_destroy,
  69                                  ret, mutex, SYNC_PTHREAD_MUTEX,
  70                                  SYNC_API_OTHER, "p", mutex);
  71
  72         return ret;
  73 }
  74
  75 int real_pthread_mutex_lock(pthread_mutex_t *mutex) {
  76         static int (*pthread_mutex_lockp)(pthread_mutex_t *mutex);
  77
  78         GET_REAL_FUNC(pthread_mutex_lock, LIBPTHREAD);
  79
  80         return pthread_mutex_lockp(mutex);
  81 }
  82
  83 int pthread_mutex_lock(pthread_mutex_t *mutex) {
  84         static int (*pthread_mutex_lockp)(pthread_mutex_t *mutex);
  85
  86         DECLARE_VARIABLE_STANDARD;
  87         GET_REAL_FUNC(pthread_mutex_lock, LIBPTHREAD);
  88
  89         PRE_PROBEBLOCK_BEGIN();
  90
  91         PREPARE_LOCAL_BUF();
  92         PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
  93                           API_ID_pthread_mutex_lock,
  94                           "p", mutex);
  95         PACK_COMMON_END(0, 0, blockresult);
  96         PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_START);
  97         FLUSH_LOCAL_BUF();
  98
  99         PRE_PROBEBLOCK_END();
 100
 101         ret = pthread_mutex_lockp(mutex);
 102
 103         // send WAIT_END log
 104         newerrno = errno;
 105         if(postBlockBegin(blockresult)) {
 106                 setProbePoint(&probeInfo);
 107
 108                 PREPARE_LOCAL_BUF();
 109                 PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
 110                                   API_ID_pthread_mutex_lock,
 111                                   "p", mutex);
 112                 PACK_COMMON_END(ret, errno, blockresult);
 113                 PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_END);
 114                 FLUSH_LOCAL_BUF();
 115
 116                 postBlockEnd();
 117         }
 118
 119         return ret;
 120 }
 121
 122 int pthread_mutex_timedlock(pthread_mutex_t *mutex,
 123                 const struct timespec *abs_timeout) {
 124         static int (*pthread_mutex_timedlockp)(pthread_mutex_t *mutex,
 125                         const struct timespec *abs_timeout);
 126
 127         DECLARE_VARIABLE_STANDARD;
 128         GET_REAL_FUNC(pthread_mutex_timedlock, LIBPTHREAD);
 129
 130         PRE_PROBEBLOCK_BEGIN();
 131
 132         PREPARE_LOCAL_BUF();
 133         PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
 134                           API_ID_pthread_mutex_timedlock,
 135                           "pp", mutex, abs_timeout);
 136         PACK_COMMON_END(0, 0, blockresult);
 137         PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_START);
 138         FLUSH_LOCAL_BUF();
 139
 140         PRE_PROBEBLOCK_END();
 141
 142         ret = pthread_mutex_timedlockp(mutex, abs_timeout);
 143
 144         // send WAIT_END log
 145         newerrno = errno;
 146         if(postBlockBegin(blockresult)) {
 147                 setProbePoint(&probeInfo);
 148
 149                 PREPARE_LOCAL_BUF();
 150                 PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
 151                                   API_ID_pthread_mutex_timedlock,
 152                                   "pp", mutex, abs_timeout);
 153                 PACK_COMMON_END(ret, errno, blockresult);
 154                 PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_END);
 155                 FLUSH_LOCAL_BUF();
 156
 157                 postBlockEnd();
 158         }
 159
 160         return ret;
 161 }
 162
 163 int pthread_mutex_trylock(pthread_mutex_t *mutex) {
 164         static int (*pthread_mutex_trylockp)(pthread_mutex_t *mutex);
 165
 166         BEFORE_ORIGINAL_SYNC(pthread_mutex_trylock, LIBPTHREAD);
 167
 168         ret = pthread_mutex_trylockp(mutex);
 169
 170         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutex_trylock,
 171                                  ret, mutex, SYNC_PTHREAD_MUTEX,
 172                                  SYNC_API_TRY_ACQUIRE, "p", mutex);
 173
 174         return ret;
 175 }
 176
 177 int real_pthread_mutex_unlock(pthread_mutex_t *mutex) {
 178         static int (*pthread_mutex_unlockp)(pthread_mutex_t *mutex);
 179
 180         GET_REAL_FUNC(pthread_mutex_unlock, LIBPTHREAD);
 181
 182         return pthread_mutex_unlockp(mutex);
 183 }
 184
 185 int pthread_mutex_unlock(pthread_mutex_t *mutex) {
 186         static int (*pthread_mutex_unlockp)(pthread_mutex_t *mutex);
 187
 188         BEFORE_ORIGINAL_SYNC(pthread_mutex_unlock, LIBPTHREAD);
 189
 190         ret = pthread_mutex_unlockp(mutex);
 191
 192         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutex_unlock,
 193                                  ret, mutex, SYNC_PTHREAD_MUTEX,
 194                                  SYNC_API_RELEASE, "p", mutex);
 195
 196         return ret;
 197 }
 198
 199 int pthread_mutexattr_init(pthread_mutexattr_t *attr) {
 200         static int (*pthread_mutexattr_initp)(pthread_mutexattr_t *attr);
 201
 202         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_init, LIBPTHREAD);
 203
 204         ret = pthread_mutexattr_initp(attr);
 205
 206         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_init,
 207                                  ret, 0, SYNC_PTHREAD_MUTEX,
 208                                  SYNC_API_OTHER, "p", attr);
 209
 210         return ret;
 211 }
 212
 213 int pthread_mutexattr_destroy(pthread_mutexattr_t *attr) {
 214         static int (*pthread_mutexattr_destroyp)(pthread_mutexattr_t *attr);
 215
 216         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_destroy, LIBPTHREAD);
 217
 218         ret = pthread_mutexattr_destroyp(attr);
 219
 220         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_destroy,
 221                                  ret, 0, SYNC_PTHREAD_MUTEX,
 222                                  SYNC_API_OTHER, "p", attr);
 223
 224         return ret;
 225 }
 226
 227 int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *attr,
 228                 int *prioceiling) {
 229         static int (*pthread_mutexattr_getprioceilingp)(
 230                         const pthread_mutexattr_t *attr, int *prioceiling);
 231
 232         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_getprioceiling, LIBPTHREAD);
 233
 234         ret = pthread_mutexattr_getprioceilingp(attr, prioceiling);
 235
 236         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_getprioceiling,
 237                                  ret, 0, SYNC_PTHREAD_MUTEX,
 238                                  SYNC_API_OTHER, "pp", attr, prioceiling);
 239
 240         return ret;
 241 }
 242
 243 int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *attr,
 244                 int prioceiling) {
 245         static int (*pthread_mutexattr_setprioceilingp)(
 246                         pthread_mutexattr_t *attr, int prioceiling);
 247
 248         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_setprioceiling, LIBPTHREAD);
 249
 250         ret = pthread_mutexattr_setprioceilingp(attr, prioceiling);
 251
 252         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_setprioceiling,
 253                                  ret, 0, SYNC_PTHREAD_MUTEX,
 254                                  SYNC_API_OTHER, "pd", attr, prioceiling);
 255
 256         return ret;
 257 }
 258
 259 int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *attr,
 260                 int *protocol) {
 261         static int (*pthread_mutexattr_getprotocolp)(
 262                         const pthread_mutexattr_t *attr, int *protocol);
 263
 264         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_getprotocol, LIBPTHREAD);
 265
 266         ret = pthread_mutexattr_getprotocolp(attr, protocol);
 267
 268         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_getprotocol,
 269                                  ret, 0, SYNC_PTHREAD_MUTEX,
 270                                  SYNC_API_OTHER, "pp", attr, protocol);
 271
 272         return ret;
 273 }
 274
 275 int pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr,
 276                 int protocol) {
 277         static int (*pthread_mutexattr_setprotocolp)(
 278                         pthread_mutexattr_t *attr, int protocol);
 279
 280         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_setprotocol, LIBPTHREAD);
 281
 282         ret = pthread_mutexattr_setprotocolp(attr, protocol);
 283
 284         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_setprotocol,
 285                                  ret, 0, SYNC_PTHREAD_MUTEX,
 286                                  SYNC_API_OTHER, "pd", attr, protocol);
 287
 288         return ret;
 289 }
 290
 291 int pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr,
 292                 int *pshared) {
 293         static int (*pthread_mutexattr_getpsharedp)(
 294                         const pthread_mutexattr_t *attr, int *pshared);
 295
 296         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_getpshared, LIBPTHREAD);
 297
 298         ret = pthread_mutexattr_getpsharedp(attr, pshared);
 299
 300         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_getpshared,
 301                                  ret, 0, SYNC_PTHREAD_MUTEX,
 302                                  SYNC_API_OTHER, "pp", attr, pshared);
 303
 304         return ret;
 305 }
 306
 307 int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr,
 308                 int pshared) {
 309         static int (*pthread_mutexattr_setpsharedp)(
 310                         pthread_mutexattr_t *attr, int pshared);
 311
 312         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_setpshared, LIBPTHREAD);
 313
 314         ret = pthread_mutexattr_setpsharedp(attr, pshared);
 315
 316         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_setpshared,
 317                                  ret, 0, SYNC_PTHREAD_MUTEX,
 318                                  SYNC_API_OTHER, "pd", attr, pshared);
 319
 320         return ret;
 321 }
 322
 323 int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type) {
 324         static int (*pthread_mutexattr_gettypep)(
 325                         const pthread_mutexattr_t *attr, int *type);
 326
 327         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_gettype, LIBPTHREAD);
 328
 329         ret = pthread_mutexattr_gettypep(attr, type);
 330
 331         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_gettype,
 332                                  ret, 0, SYNC_PTHREAD_MUTEX,
 333                                  SYNC_API_OTHER, "pp", attr, type);
 334
 335         return ret;
 336 }
 337
 338 int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type) {
 339         static int (*pthread_mutexattr_settypep)(
 340                         pthread_mutexattr_t *attr, int type);
 341
 342         BEFORE_ORIGINAL_SYNC(pthread_mutexattr_settype, LIBPTHREAD);
 343
 344         ret = pthread_mutexattr_settypep(attr, type);
 345
 346         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_settype,
 347                                  ret, 0, SYNC_PTHREAD_MUTEX,
 348                                  SYNC_API_OTHER, "pd", attr, type);
 349
 350         return ret;
 351 }
 352
 353 /*
 354 int pthread_mutex_getprioceiling(const pthread_mutex_t *mutex,
 355                 int *prioceiling);
 356 int pthread_mutex_setprioceiling(pthread_mutex_t *mutex,
 357                 int prioceiling, int *old_ceiling);
 358 */
 359
 360 int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr) {
 361         static int (*pthread_cond_initp)(pthread_cond_t *cond,
 362                         const pthread_condattr_t *attr);
 363
 364         BEFORE_ORIGINAL_SYNC(pthread_cond_init, LIBPTHREAD);
 365
 366         ret = pthread_cond_initp(cond, attr);
 367
 368         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_cond_init,
 369                                  ret, cond, SYNC_PTHREAD_COND_VARIABLE,
 370                                  SYNC_API_OTHER, "pp", cond, attr);
 371
 372         return ret;
 373 }
 374
 375 int pthread_cond_destroy(pthread_cond_t *cond) {
 376         static int (*pthread_cond_destroyp)(pthread_cond_t *cond);
 377
 378         BEFORE_ORIGINAL_SYNC(pthread_cond_destroy, LIBPTHREAD);
 379
 380         ret = pthread_cond_destroyp(cond);
 381
 382         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_cond_destroy,
 383                                  ret, cond, SYNC_PTHREAD_COND_VARIABLE,
 384                                  SYNC_API_OTHER, "p", cond);
 385
 386         return ret;
 387 }
 388
 389 int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) {
 390         static int (*pthread_cond_waitp)(pthread_cond_t *cond,
 391                         pthread_mutex_t *mutex);
 392
 393         DECLARE_VARIABLE_STANDARD;
 394         GET_REAL_FUNC(pthread_cond_wait, LIBPTHREAD);
 395
 396         PRE_PROBEBLOCK_BEGIN();
 397         // send WAIT_START log
 398
 399         PREPARE_LOCAL_BUF();
 400         PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
 401                           API_ID_pthread_cond_wait,
 402                           "pp", cond, mutex);
 403         PACK_COMMON_END(0, 0, blockresult);
 404         PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_START);
 405         FLUSH_LOCAL_BUF();
 406
 407         PRE_PROBEBLOCK_END();
 408
 409         ret = pthread_cond_waitp(cond, mutex);
 410
 411         // send WAIT_END log
 412         newerrno = errno;
 413         if(postBlockBegin(blockresult)) {
 414                 setProbePoint(&probeInfo);
 415
 416                 PREPARE_LOCAL_BUF();
 417                 PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
 418                                   API_ID_pthread_cond_wait,
 419                                   "pp", cond, mutex);
 420                 PACK_COMMON_END(ret, errno, blockresult);
 421                 PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_END);
 422                 FLUSH_LOCAL_BUF();
 423
 424                 postBlockEnd();
 425         }
 426
 427         return ret;
 428 }
 429
 430 int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
 431                 const struct timespec *abstime) {
 432         static int (*pthread_cond_timedwaitp)(pthread_cond_t *cond,
 433                                 pthread_mutex_t *mutex, const struct timespec *abstime);
 434
 435         DECLARE_VARIABLE_STANDARD;
 436         GET_REAL_FUNC(pthread_cond_timedwait, LIBPTHREAD);
 437
 438         PRE_PROBEBLOCK_BEGIN();
 439         // send WAIT_START log
 440
 441         PREPARE_LOCAL_BUF();
 442         PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
 443                           API_ID_pthread_cond_timedwait,
 444                           "ppp", cond, mutex, abstime);
 445         PACK_COMMON_END(0, 0, blockresult);
 446         PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_START);
 447         FLUSH_LOCAL_BUF();
 448
 449         PRE_PROBEBLOCK_END();
 450
 451         ret = pthread_cond_timedwaitp(cond, mutex, abstime);
 452
 453         // send WAIT_END log
 454         newerrno = errno;
 455         if(postBlockBegin(blockresult)) {
 456                 setProbePoint(&probeInfo);
 457
 458                 PREPARE_LOCAL_BUF();
 459                 PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
 460                                   API_ID_pthread_cond_timedwait,
 461                                   "ppp", cond, mutex, abstime);
 462                 PACK_COMMON_END(ret, errno, blockresult);
 463                 PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_END);
 464                 FLUSH_LOCAL_BUF();
 465
 466                 postBlockEnd();
 467         }
 468
 469         return ret;
 470 }
 471
 472 int pthread_cond_signal(pthread_cond_t *cond) {
 473         static int (*pthread_cond_signalp)(pthread_cond_t *cond);
 474
 475         BEFORE_ORIGINAL_SYNC(pthread_cond_signal, LIBPTHREAD);
 476
 477         ret = pthread_cond_signalp(cond);
 478
 479         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_cond_signal,
 480                                  ret, cond, SYNC_PTHREAD_COND_VARIABLE,
 481                         SYNC_API_NOTIFY, "p", cond);
 482
 483         return ret;
 484 }
 485
 486 int pthread_cond_broadcast(pthread_cond_t *cond) {
 487         static int (*pthread_cond_broadcastp)(pthread_cond_t *cond);
 488
 489         BEFORE_ORIGINAL_SYNC(pthread_cond_broadcast, LIBPTHREAD);
 490
 491         ret = pthread_cond_broadcastp(cond);
 492
 493         AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_cond_broadcast,
 494                                  ret, cond, SYNC_PTHREAD_COND_VARIABLE,
 495                                  SYNC_API_NOTIFY_ALL, "p", cond);
 496
 497         return ret;
 498 }
 499
 500 /*
 501 int pthread_condattr_init(pthread_condattr_t *attr);
 502 int pthread_condattr_destroy(pthread_condattr_t *attr);
 503 int pthread_condattr_getclock(const pthread_condattr_t *attr,
 504                 clockid_t *clock_id);
 505 int pthread_condattr_setclock(pthread_condattr_t *attr,
 506                 clockid_t clock_id);
 507 int pthread_condattr_getpshared(const pthread_condattr_t *attr, int *pshared);
 508 int pthread_condattr_setpshared(pthread_condattr_t *attr, int pshared);
 509 */
 510
 511 /*
 512 int pthread_rwlock_init(pthread_rwlock_t *rwlock,
 513                 const pthread_rwlockattr_t *attr);
 514 int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
 515 int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
 516 int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
 517 int pthread_rwlock_timedrdlock(pthread_rwlock_t *rwlock,
 518                 const struct timespec *abs_timeout);
 519 int pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock,
 520                 const struct timespec *abs_timeout);
 521 int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
 522 int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
 523 int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
 524 int pthread_rwlockattr_init(pthread_rwlockattr_t *attr);
 525 int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr);
 526 int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *attr,
 527                 int *pshared);
 528 int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *attr,
 529                 int pshared);
 530
 531 int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
 532 int pthread_spin_destroy(pthread_spinlock_t *lock);
 533 int pthread_spin_lock(pthread_spinlock_t *lock);
 534 int pthread_spin_trylock(pthread_spinlock_t *lock);
 535 int pthread_spin_unlock(pthread_spinlock_t *lock);
 536
 537 int pthread_barrier_init(pthread_barrier_t *barrier,
 538                 const pthread_barrierattr_t *attr, unsigned int count);
 539 int pthread_barrier_destroy(pthread_barrier_t *barrier);
 540 int pthread_barrier_wait(pthread_barrier_t *barrier);
 541 int pthread_barrierattr_init(pthread_barrierattr_t *attr);
 542 int pthread_barrierattr_destroy(pthread_barrierattr_t *attr);
 543 int pthread_barrierattr_getpshared(const pthread_barrierattr_t *attr,
 544                 int *pshared);
 545 int pthread_barrierattr_setpshared(pthread_barrierattr_t,
 546                 int pshared);
 547 */
 548