compiler/pthread/pthread.c

   1 /*
   2   Copyright (C) 2014 Szilard Biro
   3
   4   This software is provided 'as-is', without any express or implied
   5   warranty.  In no event will the authors be held liable for any damages
   6   arising from the use of this software.
   7
   8   Permission is granted to anyone to use this software for any purpose,
   9   including commercial applications, and to alter it and redistribute it
  10   freely, subject to the following restrictions:
  11
  12   1. The origin of this software must not be misrepresented; you must not
  13      claim that you wrote the original software. If you use this software
  14      in a product, an acknowledgment in the product documentation would be
  15      appreciated but is not required.
  16   2. Altered source versions must be plainly marked as such, and must not be
  17      misrepresented as being the original software.
  18   3. This notice may not be removed or altered from any source distribution.
  19 */
  20
  21 #ifdef __MORPHOS__
  22 #include <sys/time.h>
  23 #endif
  24 #include <dos/dostags.h>
  25 #include <proto/exec.h>
  26 #include <proto/dos.h>
  27 #include <proto/timer.h>
  28 #ifdef __AROS__
  29 #include <aros/symbolsets.h>
  30 #define    TIMESPEC_TO_TIMEVAL(tv, ts) {    \
  31     (tv)->tv_sec = (ts)->tv_sec;        \
  32     (tv)->tv_usec = (ts)->tv_nsec / 1000; }
  33 #else
  34 #include <constructor.h>
  35 #define StackSwapArgs PPCStackSwapArgs
  36 #define NewStackSwap NewPPCStackSwap
  37 #endif
  38
  39 #include <setjmp.h>
  40 #include <string.h>
  41 #include <stdio.h>
  42 #include <signal.h>
  43 #include <stdlib.h>
  44
  45 #include "pthread.h"
  46 #include "debug.h"
  47
  48 #define SIGB_PARENT SIGBREAKB_CTRL_F
  49 #define SIGF_PARENT (1 << SIGB_PARENT)
  50 #define SIGB_COND_FALLBACK SIGBREAKB_CTRL_E
  51 #define SIGF_COND_FALLBACK (1 << SIGB_COND_FALLBACK)
  52 #define SIGB_TIMER_FALLBACK SIGBREAKB_CTRL_D
  53 #define SIGF_TIMER_FALLBACK (1 << SIGB_TIMER_FALLBACK)
  54
  55 #define NAMELEN 32
  56 #define PTHREAD_FIRST_THREAD_ID (1)
  57 #define PTHREAD_BARRIER_FLAG (1UL << 31)
  58
  59 //#define USE_ASYNC_CANCEL
  60
  61 typedef struct
  62 {
  63     struct MinNode node;
  64     struct Task *task;
  65     ULONG sigmask;
  66 } CondWaiter;
  67
  68 typedef struct
  69 {
  70     void (*destructor)(void *);
  71     BOOL used;
  72 } TLSKey;
  73
  74 typedef struct
  75 {
  76     struct MinNode node;
  77     void (*routine)(void *);
  78     void *arg;
  79 } CleanupHandler;
  80
  81 typedef struct
  82 {
  83     void *(*start)(void *);
  84     void *arg;
  85     struct Task *parent;
  86     int finished;
  87     struct Task *task;
  88     void *ret;
  89     jmp_buf jmp;
  90     pthread_attr_t attr;
  91     void *tlsvalues[PTHREAD_KEYS_MAX];
  92     struct MinList cleanup;
  93     int cancelstate;
  94     int canceltype;
  95     int canceled;
  96 } ThreadInfo;
  97
  98 static ThreadInfo threads[PTHREAD_THREADS_MAX];
  99 static struct SignalSemaphore thread_sem;
 100 static TLSKey tlskeys[PTHREAD_KEYS_MAX];
 101 static struct SignalSemaphore tls_sem;
 102
 103 //
 104 // Helper functions
 105 //
 106
 107 static int SemaphoreIsInvalid(struct SignalSemaphore *sem)
 108 {
 109     DB2(bug("%s(%p)\n", __FUNCTION__, sem));
 110
 111     return (!sem || sem->ss_Link.ln_Type != NT_SIGNALSEM || sem->ss_WaitQueue.mlh_Tail != NULL);
 112 }
 113
 114 static int SemaphoreIsMine(struct SignalSemaphore *sem)
 115 {
 116     struct Task *me;
 117
 118     DB2(bug("%s(%p)\n", __FUNCTION__, sem));
 119
 120     me = FindTask(NULL);
 121
 122     return (sem && sem->ss_NestCount > 0 && sem->ss_Owner == me);
 123 }
 124
 125 static ThreadInfo *GetThreadInfo(pthread_t thread)
 126 {
 127     ThreadInfo *inf = NULL;
 128
 129     DB2(bug("%s(%u)\n", __FUNCTION__, thread));
 130
 131     // TODO: more robust error handling?
 132     if (thread < PTHREAD_THREADS_MAX)
 133         inf = &threads[thread];
 134
 135     return inf;
 136 }
 137
 138 static pthread_t GetThreadId(struct Task *task)
 139 {
 140     pthread_t i;
 141
 142     DB2(bug("%s(%p)\n", __FUNCTION__, task));
 143
 144     ObtainSemaphoreShared(&thread_sem);
 145
 146     // First thread id will be 1 so that it is different than default value of pthread_t
 147     for (i = PTHREAD_FIRST_THREAD_ID; i < PTHREAD_THREADS_MAX; i++)
 148     {
 149         if (threads[i].task == task)
 150             break;
 151     }
 152
 153     ReleaseSemaphore(&thread_sem);
 154
 155     return i;
 156 }
 157
 158 #if defined __mc68000__
 159 /* No CAS instruction on m68k */
 160 static int __m68k_sync_val_compare_and_swap(int *v, int o, int n)
 161 {
 162     int ret;
 163
 164     Disable();
 165     if ((*v) == (o))
 166         (*v) = (n);
 167     ret = (*v);
 168     Enable();
 169
 170     return ret;
 171 }
 172 #undef __sync_val_compare_and_swap
 173 #define __sync_val_compare_and_swap(v, o, n) __m68k_sync_val_compare_and_swap(v, o, n)
 174
 175 static int __m68k_sync_lock_test_and_set(int *v, int n)
 176 {
 177     Disable();
 178     (*v) = (n);
 179     Enable();
 180
 181     return n;
 182 }
 183 #undef __sync_lock_test_and_set
 184 #define __sync_lock_test_and_set(v, n) __m68k_sync_lock_test_and_set(v, n)
 185 #undef __sync_lock_release
 186 #define __sync_lock_release(v) __m68k_sync_lock_test_and_set(v, 0)
 187
 188 static inline int __m68k_sync_add_and_fetch(int *v, int n)
 189 {
 190     int ret;
 191
 192     Disable();
 193     (*v) += (n);
 194     ret = (*v);
 195     Enable();
 196
 197     return ret;
 198 }
 199 #undef __sync_add_and_fetch
 200 #define __sync_add_and_fetch(v, n) __m68k_sync_add_and_fetch(v, n)
 201 #undef __sync_sub_and_fetch
 202 #define __sync_sub_and_fetch(v, n) __m68k_sync_add_and_fetch(v, -(n))
 203 #endif
 204
 205 //
 206 // Thread specific data functions
 207 //
 208
 209 int pthread_key_create(pthread_key_t *key, void (*destructor)(void *))
 210 {
 211     TLSKey *tls;
 212     int i;
 213
 214     D(bug("%s(%p, %p)\n", __FUNCTION__, key, destructor));
 215
 216     if (key == NULL)
 217         return EINVAL;
 218
 219     ObtainSemaphore(&tls_sem);
 220
 221     for (i = 0; i < PTHREAD_KEYS_MAX; i++)
 222     {
 223         if (tlskeys[i].used == FALSE)
 224             break;
 225     }
 226
 227     if (i == PTHREAD_KEYS_MAX)
 228     {
 229         ReleaseSemaphore(&tls_sem);
 230         return EAGAIN;
 231     }
 232
 233     tls = &tlskeys[i];
 234     tls->used = TRUE;
 235     tls->destructor = destructor;
 236
 237     ReleaseSemaphore(&tls_sem);
 238
 239     *key = i;
 240
 241     return 0;
 242 }
 243
 244 int pthread_key_delete(pthread_key_t key)
 245 {
 246     TLSKey *tls;
 247
 248     D(bug("%s(%u)\n", __FUNCTION__, key));
 249
 250     if (key >= PTHREAD_KEYS_MAX)
 251         return EINVAL;
 252
 253     tls = &tlskeys[key];
 254
 255     ObtainSemaphore(&tls_sem);
 256
 257     if (tls->used == FALSE)
 258     {
 259         ReleaseSemaphore(&tls_sem);
 260         return EINVAL;
 261     }
 262
 263     tls->used = FALSE;
 264     tls->destructor = NULL;
 265
 266     ReleaseSemaphore(&tls_sem);
 267
 268     return 0;
 269 }
 270
 271 int pthread_setspecific(pthread_key_t key, const void *value)
 272 {
 273     pthread_t thread;
 274     ThreadInfo *inf;
 275     TLSKey *tls;
 276
 277     D(bug("%s(%u)\n", __FUNCTION__, key));
 278
 279     if (key >= PTHREAD_KEYS_MAX)
 280         return EINVAL;
 281
 282     thread = pthread_self();
 283     tls = &tlskeys[key];
 284
 285     ObtainSemaphoreShared(&tls_sem);
 286
 287     if (tls->used == FALSE)
 288     {
 289         ReleaseSemaphore(&tls_sem);
 290         return EINVAL;
 291     }
 292
 293     ReleaseSemaphore(&tls_sem);
 294
 295     inf = GetThreadInfo(thread);
 296     inf->tlsvalues[key] = (void *)value;
 297
 298     return 0;
 299 }
 300
 301 void *pthread_getspecific(pthread_key_t key)
 302 {
 303     pthread_t thread;
 304     ThreadInfo *inf;
 305     void *value = NULL;
 306
 307     D(bug("%s(%u)\n", __FUNCTION__, key));
 308
 309     if (key >= PTHREAD_KEYS_MAX)
 310         return NULL;
 311
 312     thread = pthread_self();
 313     inf = GetThreadInfo(thread);
 314     value = inf->tlsvalues[key];
 315
 316     return value;
 317 }
 318
 319 //
 320 // Mutex attribute functions
 321 //
 322
 323 int pthread_mutexattr_init(pthread_mutexattr_t *attr)
 324 {
 325     D(bug("%s(%p)\n", __FUNCTION__, attr));
 326
 327     if (attr == NULL)
 328         return EINVAL;
 329
 330     attr->kind = PTHREAD_MUTEX_DEFAULT;
 331
 332     return 0;
 333 }
 334
 335 int pthread_mutexattr_destroy(pthread_mutexattr_t *attr)
 336 {
 337     D(bug("%s(%p)\n", __FUNCTION__, attr));
 338
 339     if (attr == NULL)
 340         return EINVAL;
 341
 342     memset(attr, 0, sizeof(pthread_mutexattr_t));
 343
 344     return 0;
 345 }
 346
 347 int pthread_mutexattr_gettype(pthread_mutexattr_t *attr, int *kind)
 348 {
 349     D(bug("%s(%p, %p)\n", __FUNCTION__, attr, kind));
 350
 351     if (attr == NULL)
 352         return EINVAL;
 353
 354     if (kind)
 355         *kind = attr->kind;
 356
 357     return 0;
 358 }
 359
 360 int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind)
 361 {
 362     D(bug("%s(%p)\n", __FUNCTION__, attr));
 363
 364     if (attr == NULL || !(kind >= PTHREAD_MUTEX_NORMAL && kind <= PTHREAD_MUTEX_ERRORCHECK))
 365         return EINVAL;
 366
 367     attr->kind = kind;
 368
 369     return 0;
 370 }
 371
 372 //
 373 // Mutex functions
 374 //
 375
 376 static int _pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr, BOOL staticinit)
 377 {
 378     DB2(bug("%s(%p, %p)\n", __FUNCTION__, mutex, attr));
 379
 380     if (mutex == NULL)
 381         return EINVAL;
 382
 383     if (attr)
 384         mutex->kind = attr->kind;
 385     else if (!staticinit)
 386         mutex->kind = PTHREAD_MUTEX_DEFAULT;
 387     InitSemaphore(&mutex->semaphore);
 388     mutex->incond = 0;
 389
 390     return 0;
 391 }
 392
 393 int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
 394 {
 395     D(bug("%s(%p, %p)\n", __FUNCTION__, mutex, attr));
 396
 397     return _pthread_mutex_init(mutex, attr, FALSE);
 398 }
 399
 400 int pthread_mutex_destroy(pthread_mutex_t *mutex)
 401 {
 402     D(bug("%s(%p)\n", __FUNCTION__, mutex));
 403
 404     if (mutex == NULL)
 405         return EINVAL;
 406
 407     // probably a statically allocated mutex
 408     if (SemaphoreIsInvalid(&mutex->semaphore))
 409         return 0;
 410
 411     if (/*mutex->incond ||*/ AttemptSemaphore(&mutex->semaphore) == FALSE)
 412         return EBUSY;
 413
 414     if (mutex->incond)
 415     {
 416         ReleaseSemaphore(&mutex->semaphore);
 417         return EBUSY;
 418     }
 419
 420     ReleaseSemaphore(&mutex->semaphore);
 421     memset(mutex, 0, sizeof(pthread_mutex_t));
 422
 423     return 0;
 424 }
 425
 426 int pthread_mutex_lock(pthread_mutex_t *mutex)
 427 {
 428     D(bug("%s(%p)\n", __FUNCTION__, mutex));
 429
 430     if (mutex == NULL)
 431         return EINVAL;
 432
 433     // initialize static mutexes
 434     if (SemaphoreIsInvalid(&mutex->semaphore))
 435         _pthread_mutex_init(mutex, NULL, TRUE);
 436
 437     // normal mutexes would simply deadlock here
 438     if (mutex->kind == PTHREAD_MUTEX_ERRORCHECK && SemaphoreIsMine(&mutex->semaphore))
 439         return EDEADLK;
 440
 441     ObtainSemaphore(&mutex->semaphore);
 442
 443     return 0;
 444 }
 445
 446 int pthread_mutex_timedlock(pthread_mutex_t *mutex, const struct timespec *abstime)
 447 {
 448     struct timeval end, now;
 449     int result;
 450
 451     D(bug("%s(%p, %p)\n", __FUNCTION__, mutex, abstime));
 452
 453     if (mutex == NULL)
 454         return EINVAL;
 455
 456     if (abstime == NULL)
 457         return pthread_mutex_lock(mutex);
 458     /*else if (abstime.tv_nsec < 0 || abstime.tv_nsec >= 1000000000)
 459         return EINVAL;*/
 460
 461     TIMESPEC_TO_TIMEVAL(&end, abstime);
 462
 463     // busy waiting is not very nice, but ObtainSemaphore doesn't support timeouts
 464     while ((result = pthread_mutex_trylock(mutex)) == EBUSY)
 465     {
 466         sched_yield();
 467         gettimeofday(&now, NULL);
 468         if (timercmp(&end, &now, <))
 469             return ETIMEDOUT;
 470     }
 471
 472     return result;
 473 }
 474
 475 int pthread_mutex_trylock(pthread_mutex_t *mutex)
 476 {
 477     ULONG ret;
 478
 479     D(bug("%s(%p)\n", __FUNCTION__, mutex));
 480
 481     if (mutex == NULL)
 482         return EINVAL;
 483
 484     // initialize static mutexes
 485     if (SemaphoreIsInvalid(&mutex->semaphore))
 486         _pthread_mutex_init(mutex, NULL, TRUE);
 487
 488     if (mutex->kind != PTHREAD_MUTEX_RECURSIVE && SemaphoreIsMine(&mutex->semaphore))
 489         return EBUSY;
 490
 491     ret = AttemptSemaphore(&mutex->semaphore);
 492
 493     return (ret == TRUE) ? 0 : EBUSY;
 494 }
 495
 496 int pthread_mutex_unlock(pthread_mutex_t *mutex)
 497 {
 498     D(bug("%s(%p)\n", __FUNCTION__, mutex));
 499
 500     if (mutex == NULL)
 501         return EINVAL;
 502
 503     // initialize static mutexes
 504     if (SemaphoreIsInvalid(&mutex->semaphore))
 505         _pthread_mutex_init(mutex, NULL, TRUE);
 506
 507     if (mutex->kind != PTHREAD_MUTEX_NORMAL && !SemaphoreIsMine(&mutex->semaphore))
 508         return EPERM;
 509
 510     ReleaseSemaphore(&mutex->semaphore);
 511
 512     return 0;
 513 }
 514
 515 //
 516 // Condition variable attribute functions
 517 //
 518
 519 int pthread_condattr_init(pthread_condattr_t *attr)
 520 {
 521     D(bug("%s(%p)\n", __FUNCTION__, attr));
 522
 523     if (attr == NULL)
 524         return EINVAL;
 525
 526     memset(attr, 0, sizeof(pthread_condattr_t));
 527
 528     return 0;
 529 }
 530
 531 int pthread_condattr_destroy(pthread_condattr_t *attr)
 532 {
 533     D(bug("%s(%p)\n", __FUNCTION__, attr));
 534
 535     if (attr == NULL)
 536         return EINVAL;
 537
 538     memset(attr, 0, sizeof(pthread_condattr_t));
 539
 540     return 0;
 541 }
 542
 543 //
 544 // Condition variable functions
 545 //
 546
 547 int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
 548 {
 549     D(bug("%s(%p, %p)\n", __FUNCTION__, cond, attr));
 550
 551     if (cond == NULL)
 552         return EINVAL;
 553
 554     InitSemaphore(&cond->semaphore);
 555     NEWLIST((struct List *)&cond->waiters);
 556
 557     return 0;
 558 }
 559
 560 int pthread_cond_destroy(pthread_cond_t *cond)
 561 {
 562     D(bug("%s(%p)\n", __FUNCTION__, cond));
 563
 564     if (cond == NULL)
 565         return EINVAL;
 566
 567     // probably a statically allocated condition
 568     if (SemaphoreIsInvalid(&cond->semaphore))
 569         return 0;
 570
 571     if (AttemptSemaphore(&cond->semaphore) == FALSE)
 572         return EBUSY;
 573
 574     if (!IsListEmpty((struct List *)&cond->waiters))
 575     {
 576         ReleaseSemaphore(&cond->semaphore);
 577         return EBUSY;
 578     }
 579
 580     ReleaseSemaphore(&cond->semaphore);
 581     memset(cond, 0, sizeof(pthread_cond_t));
 582
 583     return 0;
 584 }
 585
 586 static int _pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime, BOOL relative)
 587 {
 588     CondWaiter waiter;
 589     BYTE signal;
 590     ULONG sigs = 0;
 591     ULONG timermask = 0;
 592     struct MsgPort timermp;
 593     struct timerequest timerio;
 594     struct Task *task;
 595
 596     DB2(bug("%s(%p, %p, %p)\n", __FUNCTION__, cond, mutex, abstime));
 597
 598     if (cond == NULL || mutex == NULL)
 599         return EINVAL;
 600
 601     pthread_testcancel();
 602
 603     // initialize static conditions
 604     if (SemaphoreIsInvalid(&cond->semaphore))
 605         pthread_cond_init(cond, NULL);
 606
 607     task = FindTask(NULL);
 608
 609     if (abstime)
 610     {
 611         // prepare MsgPort
 612         timermp.mp_Node.ln_Type = NT_MSGPORT;
 613         timermp.mp_Node.ln_Pri = 0;
 614         timermp.mp_Node.ln_Name = NULL;
 615         timermp.mp_Flags = PA_SIGNAL;
 616         timermp.mp_SigTask = task;
 617         signal = AllocSignal(-1);
 618         if (signal == -1)
 619         {
 620             signal = SIGB_TIMER_FALLBACK;
 621             SetSignal(SIGF_TIMER_FALLBACK, 0);
 622         }
 623         timermp.mp_SigBit = signal;
 624         NEWLIST(&timermp.mp_MsgList);
 625
 626         // prepare IORequest
 627         timerio.tr_node.io_Message.mn_Node.ln_Type = NT_MESSAGE;
 628         timerio.tr_node.io_Message.mn_Node.ln_Pri = 0;
 629         timerio.tr_node.io_Message.mn_Node.ln_Name = NULL;
 630         timerio.tr_node.io_Message.mn_ReplyPort = &timermp;
 631         timerio.tr_node.io_Message.mn_Length = sizeof(struct timerequest);
 632
 633         // open timer.device
 634         if (OpenDevice((STRPTR)TIMERNAME, UNIT_MICROHZ, &timerio.tr_node, 0) != 0)
 635         {
 636             if (timermp.mp_SigBit != SIGB_TIMER_FALLBACK)
 637                 FreeSignal(timermp.mp_SigBit);
 638
 639             return EINVAL;
 640         }
 641
 642         // prepare the device command and send it
 643         timerio.tr_node.io_Command = TR_ADDREQUEST;
 644         timerio.tr_node.io_Flags = 0;
 645         TIMESPEC_TO_TIMEVAL(&timerio.tr_time, abstime);
 646         if (!relative)
 647         {
 648             struct timeval starttime;
 649             // absolute time has to be converted to relative
 650             // GetSysTime can't be used due to the timezone offset in abstime
 651             gettimeofday(&starttime, NULL);
 652             timersub(&timerio.tr_time, &starttime, &timerio.tr_time);
 653         }
 654         timermask = 1 << timermp.mp_SigBit;
 655         sigs |= timermask;
 656         SendIO((struct IORequest *)&timerio);
 657     }
 658
 659     // prepare a waiter node
 660     waiter.task = task;
 661     signal = AllocSignal(-1);
 662     if (signal == -1)
 663     {
 664         signal = SIGB_COND_FALLBACK;
 665         SetSignal(SIGF_COND_FALLBACK, 0);
 666     }
 667     waiter.sigmask = 1 << signal;
 668     sigs |= waiter.sigmask;
 669
 670     // add it to the end of the list
 671     ObtainSemaphore(&cond->semaphore);
 672     AddTail((struct List *)&cond->waiters, (struct Node *)&waiter);
 673     ReleaseSemaphore(&cond->semaphore);
 674
 675     // wait for the condition to be signalled or the timeout
 676     mutex->incond++;
 677     pthread_mutex_unlock(mutex);
 678     sigs = Wait(sigs);
 679     pthread_mutex_lock(mutex);
 680     mutex->incond--;
 681
 682     // remove the node from the list
 683     ObtainSemaphore(&cond->semaphore);
 684     Remove((struct Node *)&waiter);
 685     ReleaseSemaphore(&cond->semaphore);
 686
 687     if (signal != SIGB_COND_FALLBACK)
 688         FreeSignal(signal);
 689
 690     if (abstime)
 691     {
 692         // clean up the timerequest
 693         if (!CheckIO((struct IORequest *)&timerio))
 694         {
 695             AbortIO((struct IORequest *)&timerio);
 696             WaitIO((struct IORequest *)&timerio);
 697         }
 698         CloseDevice((struct IORequest *)&timerio);
 699
 700         if (timermp.mp_SigBit != SIGB_TIMER_FALLBACK)
 701             FreeSignal(timermp.mp_SigBit);
 702
 703         // did we timeout?
 704         if (sigs & timermask)
 705             return ETIMEDOUT;
 706     }
 707
 708     return 0;
 709 }
 710
 711 int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
 712 {
 713     D(bug("%s(%p, %p, %p)\n", __FUNCTION__, cond, mutex, abstime));
 714
 715     return _pthread_cond_timedwait(cond, mutex, abstime, FALSE);
 716 }
 717
 718 int pthread_cond_timedwait_relative_np(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *reltime)
 719 {
 720     D(bug("%s(%p, %p, %p)\n", __FUNCTION__, cond, mutex, reltime));
 721
 722     return _pthread_cond_timedwait(cond, mutex, reltime, TRUE);
 723 }
 724
 725 int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
 726 {
 727     D(bug("%s(%p)\n", __FUNCTION__, cond));
 728
 729     return _pthread_cond_timedwait(cond, mutex, NULL, FALSE);
 730 }
 731
 732 static int _pthread_cond_broadcast(pthread_cond_t *cond, BOOL onlyfirst)
 733 {
 734     CondWaiter *waiter;
 735
 736     DB2(bug("%s(%p, %d)\n", __FUNCTION__, cond, onlyfirst));
 737
 738     if (cond == NULL)
 739         return EINVAL;
 740
 741     // initialize static conditions
 742     if (SemaphoreIsInvalid(&cond->semaphore))
 743         pthread_cond_init(cond, NULL);
 744
 745     // signal the waiting threads
 746     ObtainSemaphore(&cond->semaphore);
 747     ForeachNode(&cond->waiters, waiter)
 748     {
 749         Signal(waiter->task, waiter->sigmask);
 750         if (onlyfirst) break;
 751     }
 752     ReleaseSemaphore(&cond->semaphore);
 753
 754     return 0;
 755 }
 756
 757 int pthread_cond_signal(pthread_cond_t *cond)
 758 {
 759     D(bug("%s(%p)\n", __FUNCTION__, cond));
 760
 761     return _pthread_cond_broadcast(cond, TRUE);
 762 }
 763
 764 int pthread_cond_broadcast(pthread_cond_t *cond)
 765 {
 766     D(bug("%s(%p)\n", __FUNCTION__, cond));
 767
 768     return _pthread_cond_broadcast(cond, FALSE);
 769 }
 770
 771 //
 772 // Barrier functions
 773 //
 774
 775 int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count)
 776 {
 777     D(bug("%s(%p, %p, %u)\n", __FUNCTION__, barrier, attr, count));
 778
 779     if (barrier == NULL || count == 0)
 780         return EINVAL;
 781
 782     barrier->curr_height = count;
 783     barrier->total_height = PTHREAD_BARRIER_FLAG;
 784     pthread_cond_init(&barrier->breeched, NULL);
 785     pthread_mutex_init(&barrier->lock, NULL);
 786
 787     return 0;
 788 }
 789
 790 int pthread_barrier_destroy(pthread_barrier_t *barrier)
 791 {
 792     D(bug("%s(%p)\n", __FUNCTION__, barrier));
 793
 794     if (barrier == NULL)
 795         return EINVAL;
 796
 797     if (pthread_mutex_trylock(&barrier->lock) != 0)
 798         return EBUSY;
 799
 800     if (barrier->total_height > PTHREAD_BARRIER_FLAG)
 801     {
 802         pthread_mutex_unlock(&barrier->lock);
 803         return EBUSY;
 804     }
 805
 806     pthread_mutex_unlock(&barrier->lock);
 807
 808     if (pthread_cond_destroy(&barrier->breeched) != 0)
 809         return EBUSY;
 810
 811     pthread_mutex_destroy(&barrier->lock);
 812     barrier->curr_height = barrier->total_height = 0;
 813
 814     return 0;
 815 }
 816
 817 int pthread_barrier_wait(pthread_barrier_t *barrier)
 818 {
 819     D(bug("%s(%p)\n", __FUNCTION__, barrier));
 820
 821     if (barrier == NULL)
 822         return EINVAL;
 823
 824     pthread_mutex_lock(&barrier->lock);
 825
 826     // wait until everyone exits the barrier
 827     while (barrier->total_height > PTHREAD_BARRIER_FLAG)
 828         pthread_cond_wait(&barrier->breeched, &barrier->lock);
 829
 830     // are we the first to enter?
 831     if (barrier->total_height == PTHREAD_BARRIER_FLAG) barrier->total_height = 0;
 832
 833     barrier->total_height++;
 834
 835     if (barrier->total_height == barrier->curr_height)
 836     {
 837         barrier->total_height += PTHREAD_BARRIER_FLAG - 1;
 838         pthread_cond_broadcast(&barrier->breeched);
 839
 840         pthread_mutex_unlock(&barrier->lock);
 841
 842         return PTHREAD_BARRIER_SERIAL_THREAD;
 843     }
 844     else
 845     {
 846         // wait until enough threads enter the barrier
 847         while (barrier->total_height < PTHREAD_BARRIER_FLAG)
 848             pthread_cond_wait(&barrier->breeched, &barrier->lock);
 849
 850         barrier->total_height--;
 851
 852         // get entering threads to wake up
 853         if (barrier->total_height == PTHREAD_BARRIER_FLAG)
 854             pthread_cond_broadcast(&barrier->breeched);
 855
 856         pthread_mutex_unlock(&barrier->lock);
 857
 858         return 0;
 859     }
 860 }
 861
 862 //
 863 // Read-write lock attribute functions
 864 //
 865
 866 int pthread_rwlockattr_init(pthread_rwlockattr_t *attr)
 867 {
 868     D(bug("%s(%p)\n", __FUNCTION__, attr));
 869
 870     if (attr == NULL)
 871         return EINVAL;
 872
 873     memset(attr, 0, sizeof(pthread_rwlockattr_t));
 874
 875     return 0;
 876 }
 877
 878 int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr)
 879 {
 880     D(bug("%s(%p)\n", __FUNCTION__, attr));
 881
 882     if (attr == NULL)
 883         return EINVAL;
 884
 885     memset(attr, 0, sizeof(pthread_rwlockattr_t));
 886
 887     return 0;
 888 }
 889
 890 //
 891 // Read-write lock functions
 892 //
 893
 894 int pthread_rwlock_init(pthread_rwlock_t *lock, const pthread_rwlockattr_t *attr)
 895 {
 896     D(bug("%s(%p, %p)\n", __FUNCTION__, lock, attr));
 897
 898     if (lock == NULL)
 899         return EINVAL;
 900
 901     InitSemaphore(&lock->semaphore);
 902
 903     return 0;
 904 }
 905
 906 int pthread_rwlock_destroy(pthread_rwlock_t *lock)
 907 {
 908     D(bug("%s(%p)\n", __FUNCTION__, lock));
 909
 910     if (lock == NULL)
 911         return EINVAL;
 912
 913     // probably a statically allocated rwlock
 914     if (SemaphoreIsInvalid(&lock->semaphore))
 915         return 0;
 916
 917     if (AttemptSemaphore(&lock->semaphore) == FALSE)
 918         return EBUSY;
 919
 920     ReleaseSemaphore(&lock->semaphore);
 921     memset(lock, 0, sizeof(pthread_rwlock_t));
 922
 923     return 0;
 924 }
 925
 926 int pthread_rwlock_tryrdlock(pthread_rwlock_t *lock)
 927 {
 928     ULONG ret;
 929
 930     D(bug("%s(%p)\n", __FUNCTION__, lock));
 931
 932     if (lock == NULL)
 933         return EINVAL;
 934
 935     // initialize static rwlocks
 936     if (SemaphoreIsInvalid(&lock->semaphore))
 937         pthread_rwlock_init(lock, NULL);
 938
 939     ret = AttemptSemaphoreShared(&lock->semaphore);
 940
 941     return (ret == TRUE) ? 0 : EBUSY;
 942 }
 943
 944 int pthread_rwlock_trywrlock(pthread_rwlock_t *lock)
 945 {
 946     ULONG ret;
 947
 948     D(bug("%s(%p)\n", __FUNCTION__, lock));
 949
 950     if (lock == NULL)
 951         return EINVAL;
 952
 953     // initialize static rwlocks
 954     if (SemaphoreIsInvalid(&lock->semaphore))
 955         pthread_rwlock_init(lock, NULL);
 956
 957     ret = AttemptSemaphore(&lock->semaphore);
 958
 959     return (ret == TRUE) ? 0 : EBUSY;
 960 }
 961
 962 int pthread_rwlock_rdlock(pthread_rwlock_t *lock)
 963 {
 964     D(bug("%s(%p)\n", __FUNCTION__, lock));
 965
 966     if (lock == NULL)
 967         return EINVAL;
 968
 969     pthread_testcancel();
 970
 971     // initialize static rwlocks
 972     if (SemaphoreIsInvalid(&lock->semaphore))
 973         pthread_rwlock_init(lock, NULL);
 974
 975     // we might already have a write lock
 976     if (SemaphoreIsMine(&lock->semaphore))
 977         return EDEADLK;
 978
 979     ObtainSemaphoreShared(&lock->semaphore);
 980
 981     return 0;
 982 }
 983
 984 int pthread_rwlock_timedrdlock(pthread_rwlock_t *lock, const struct timespec *abstime)
 985 {
 986     struct timeval end, now;
 987     int result;
 988
 989     D(bug("%s(%p, %p)\n", __FUNCTION__, lock, abstime));
 990
 991     if (lock == NULL)
 992         return EINVAL;
 993
 994     if (abstime == NULL)
 995         return pthread_rwlock_rdlock(lock);
 996
 997     pthread_testcancel();
 998
 999     TIMESPEC_TO_TIMEVAL(&end, abstime);
1000
1001     // busy waiting is not very nice, but ObtainSemaphore doesn't support timeouts
1002     while ((result = pthread_rwlock_tryrdlock(lock)) == EBUSY)
1003     {
1004         sched_yield();
1005         gettimeofday(&now, NULL);
1006         if (timercmp(&end, &now, <))
1007             return ETIMEDOUT;
1008     }
1009
1010     return result;
1011 }
1012
1013 int pthread_rwlock_wrlock(pthread_rwlock_t *lock)
1014 {
1015     D(bug("%s(%p)\n", __FUNCTION__, lock));
1016
1017     if (lock == NULL)
1018         return EINVAL;
1019
1020     pthread_testcancel();
1021
1022     // initialize static rwlocks
1023     if (SemaphoreIsInvalid(&lock->semaphore))
1024         pthread_rwlock_init(lock, NULL);
1025
1026     if (SemaphoreIsMine(&lock->semaphore))
1027         return EDEADLK;
1028
1029     ObtainSemaphore(&lock->semaphore);
1030
1031     return 0;
1032 }
1033
1034 int pthread_rwlock_timedwrlock(pthread_rwlock_t *lock, const struct timespec *abstime)
1035 {
1036     struct timeval end, now;
1037     int result;
1038
1039     D(bug("%s(%p, %p)\n", __FUNCTION__, lock, abstime));
1040
1041     if (lock == NULL)
1042         return EINVAL;
1043
1044     if (abstime == NULL)
1045         return pthread_rwlock_wrlock(lock);
1046
1047     pthread_testcancel();
1048
1049     TIMESPEC_TO_TIMEVAL(&end, abstime);
1050
1051     // busy waiting is not very nice, but ObtainSemaphore doesn't support timeouts
1052     while ((result = pthread_rwlock_trywrlock(lock)) == EBUSY)
1053     {
1054         sched_yield();
1055         gettimeofday(&now, NULL);
1056         if (timercmp(&end, &now, <))
1057             return ETIMEDOUT;
1058     }
1059
1060     return result;
1061 }
1062
1063 int pthread_rwlock_unlock(pthread_rwlock_t *lock)
1064 {
1065     D(bug("%s(%p)\n", __FUNCTION__, lock));
1066
1067     if (lock == NULL)
1068         return EINVAL;
1069
1070     // initialize static rwlocks
1071     if (SemaphoreIsInvalid(&lock->semaphore))
1072         pthread_rwlock_init(lock, NULL);
1073
1074     //if (!SemaphoreIsMine(&lock->semaphore))
1075     // if no one has obtained the semaphore don't unlock the rwlock
1076     // this can be a leap of faith because we don't maintain a separate list of readers
1077     if (lock->semaphore.ss_NestCount < 1)
1078         return EPERM;
1079
1080     ReleaseSemaphore(&lock->semaphore);
1081
1082     return 0;
1083 }
1084
1085 //
1086 // Spinlock functions
1087 //
1088
1089 int pthread_spin_init(pthread_spinlock_t *lock, int pshared)
1090 {
1091     D(bug("%s(%p, %d)\n", __FUNCTION__, lock, pshared));
1092
1093     if (lock == NULL)
1094         return EINVAL;
1095
1096     *lock = 0;
1097
1098     return 0;
1099 }
1100
1101 int pthread_spin_destroy(pthread_spinlock_t *lock)
1102 {
1103     D(bug("%s(%p)\n", __FUNCTION__, lock));
1104
1105     return 0;
1106 }
1107
1108 int pthread_spin_lock(pthread_spinlock_t *lock)
1109 {
1110     D(bug("%s(%p)\n", __FUNCTION__, lock));
1111
1112     if (lock == NULL)
1113         return EINVAL;
1114
1115     while (__sync_lock_test_and_set((int *)lock, 1))
1116         sched_yield(); // TODO: don't yield the CPU every iteration
1117
1118     return 0;
1119 }
1120
1121 int pthread_spin_trylock(pthread_spinlock_t *lock)
1122 {
1123     D(bug("%s(%p)\n", __FUNCTION__, lock));
1124
1125     if (lock == NULL)
1126         return EINVAL;
1127
1128     if (__sync_lock_test_and_set((int *)lock, 1))
1129         return EBUSY;
1130
1131     return 0;
1132 }
1133
1134 int pthread_spin_unlock(pthread_spinlock_t *lock)
1135 {
1136     D(bug("%s(%p)\n", __FUNCTION__, lock));
1137
1138     if (lock == NULL)
1139         return EINVAL;
1140
1141     __sync_lock_release((int *)lock);
1142
1143     return 0;
1144 }
1145
1146 //
1147 // Thread attribute functions
1148 //
1149
1150 int pthread_attr_init(pthread_attr_t *attr)
1151 {
1152     struct Task *task;
1153
1154     D(bug("%s(%p)\n", __FUNCTION__, attr));
1155
1156     if (attr == NULL)
1157         return EINVAL;
1158
1159     memset(attr, 0, sizeof(pthread_attr_t));
1160     // inherit the priority and stack size of the parent thread
1161     task = FindTask(NULL);
1162     attr->param.sched_priority = task->tc_Node.ln_Pri;
1163     attr->stacksize = (UBYTE *)task->tc_SPUpper - (UBYTE *)task->tc_SPLower;
1164
1165     return 0;
1166 }
1167
1168 int pthread_attr_destroy(pthread_attr_t *attr)
1169 {
1170     D(bug("%s(%p)\n", __FUNCTION__, attr));
1171
1172     if (attr == NULL)
1173         return EINVAL;
1174
1175     memset(attr, 0, sizeof(pthread_attr_t));
1176
1177     return 0;
1178 }
1179
1180 int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
1181 {
1182     D(bug("%s(%p, %p)\n", __FUNCTION__, attr, detachstate));
1183
1184     if (attr == NULL)
1185         return EINVAL;
1186
1187     if (detachstate != NULL)
1188         *detachstate = attr->detachstate;
1189
1190     return 0;
1191 }
1192
1193 int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
1194 {
1195     D(bug("%s(%p, %d)\n", __FUNCTION__, attr, detachstate));
1196
1197     if (attr == NULL || detachstate != PTHREAD_CREATE_JOINABLE)
1198         return EINVAL;
1199
1200     attr->detachstate = detachstate;
1201
1202     return 0;
1203 }
1204
1205 int pthread_attr_getstack(const pthread_attr_t *attr, void **stackaddr, size_t *stacksize)
1206 {
1207     D(bug("%s(%p, %p, %p)\n", __FUNCTION__, attr, stackaddr, stacksize));
1208
1209     if (attr == NULL)
1210         return EINVAL;
1211
1212     if (stackaddr != NULL)
1213         *stackaddr = attr->stackaddr;
1214
1215     if (stacksize != NULL)
1216         *stacksize = attr->stacksize;
1217
1218     return 0;
1219 }
1220
1221 int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr, size_t stacksize)
1222 {
1223     D(bug("%s(%p, %p, %u)\n", __FUNCTION__, attr, stackaddr, stacksize));
1224
1225     if (attr == NULL || (stackaddr != NULL && stacksize == 0))
1226         return EINVAL;
1227
1228     attr->stackaddr = stackaddr;
1229     attr->stacksize = stacksize;
1230
1231     return 0;
1232 }
1233
1234 int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize)
1235 {
1236     D(bug("%s(%p, %p)\n", __FUNCTION__, attr, stacksize));
1237
1238     return pthread_attr_getstack(attr, NULL, stacksize);
1239 }
1240
1241 int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize)
1242 {
1243     D(bug("%s(%p, %u)\n", __FUNCTION__, attr, stacksize));
1244
1245     return pthread_attr_setstack(attr, NULL, stacksize);
1246 }
1247
1248 int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param)
1249 {
1250     D(bug("%s(%p, %p)\n", __FUNCTION__, attr, param));
1251
1252     if (attr == NULL)
1253         return EINVAL;
1254
1255     if (param != NULL)
1256         *param = attr->param;
1257
1258     return 0;
1259 }
1260
1261 int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param)
1262 {
1263     D(bug("%s(%p, %p)\n", __FUNCTION__, attr, param));
1264
1265     if (attr == NULL || param == NULL)
1266         return EINVAL;
1267
1268     attr->param = *param;
1269
1270     return 0;
1271 }
1272
1273 //
1274 // Thread functions
1275 //
1276
1277 #ifdef USE_ASYNC_CANCEL
1278 #ifdef __MORPHOS__
1279 static ULONG CancelHandlerFunc(void);
1280 static struct EmulLibEntry CancelHandler =
1281 {
1282     TRAP_LIB, 0, (void (*)(void))CancelHandlerFunc
1283 };
1284 static ULONG CancelHandlerFunc(void)
1285 {
1286     ULONG signals = (ULONG)REG_D0;
1287     APTR data = (APTR)REG_A1;
1288     struct ExecBase *SysBase = (struct ExecBase *)REG_A6;
1289 #else
1290 AROS_UFH3S(ULONG, CancelHandler,
1291     AROS_UFHA(ULONG, signals, D0),
1292     AROS_UFHA(APTR, data, A1),
1293     AROS_UFHA(struct ExecBase *, SysBase, A6))
1294 {
1295     AROS_USERFUNC_INIT
1296 #endif
1297
1298     DB2(bug("%s(%u, %p, %p)\n", __FUNCTION__, signals, data, SysBase));
1299
1300     pthread_testcancel();
1301
1302     return signals;
1303 #ifdef __AROS__
1304     AROS_USERFUNC_EXIT
1305 #endif
1306 }
1307 #endif
1308
1309 static void StarterFunc(void)
1310 {
1311     ThreadInfo *inf;
1312     int i, j;
1313     int foundkey = TRUE;
1314 #ifdef USE_ASYNC_CANCEL
1315     APTR oldexcept;
1316 #endif
1317
1318     DB2(bug("%s()\n", __FUNCTION__));
1319
1320     inf = (ThreadInfo *)FindTask(NULL)->tc_UserData;
1321     // trim the name
1322     //inf->task->tc_Node.ln_Name[inf->oldlen];
1323
1324     // we have to set the priority here to avoid race conditions
1325     SetTaskPri(inf->task, inf->attr.param.sched_priority);
1326
1327 #ifdef USE_ASYNC_CANCEL
1328     // set the exception handler for async cancellation
1329     oldexcept = inf->task->tc_ExceptCode;
1330 #ifdef __AROS__
1331     inf->task->tc_ExceptCode = &AROS_ASMSYMNAME(CancelHandler);
1332 #else
1333     inf->task->tc_ExceptCode = &CancelHandler;
1334 #endif
1335     SetExcept(SIGBREAKF_CTRL_C, SIGBREAKF_CTRL_C);
1336 #endif
1337
1338     // set a jump point for pthread_exit
1339     if (!setjmp(inf->jmp))
1340     {
1341         // custom stack requires special handling
1342         if (inf->attr.stackaddr != NULL && inf->attr.stacksize > 0)
1343         {
1344             struct StackSwapArgs swapargs;
1345             struct StackSwapStruct stack;
1346
1347             swapargs.Args[0] = (IPTR)inf->arg;
1348             stack.stk_Lower = inf->attr.stackaddr;
1349             stack.stk_Upper = (APTR)((IPTR)stack.stk_Lower + inf->attr.stacksize);
1350             stack.stk_Pointer = stack.stk_Upper;
1351
1352             inf->ret = (void *)NewStackSwap(&stack, inf->start, &swapargs);
1353         }
1354         else
1355         {
1356             inf->ret = inf->start(inf->arg);
1357         }
1358     }
1359
1360 #ifdef USE_ASYNC_CANCEL
1361     // remove the exception handler
1362     SetExcept(0, SIGBREAKF_CTRL_C);
1363     inf->task->tc_ExceptCode = oldexcept;
1364 #endif
1365
1366     // destroy all non-NULL TLS key values
1367     // since the destructors can set the keys themselves, we have to do multiple iterations
1368     ObtainSemaphoreShared(&tls_sem);
1369     for (j = 0; foundkey && j < PTHREAD_DESTRUCTOR_ITERATIONS; j++)
1370     {
1371         foundkey = FALSE;
1372         for (i = 0; i < PTHREAD_KEYS_MAX; i++)
1373         {
1374             if (tlskeys[i].used && tlskeys[i].destructor && inf->tlsvalues[i])
1375             {
1376                 void *oldvalue = inf->tlsvalues[i];
1377                 inf->tlsvalues[i] = NULL;
1378                 tlskeys[i].destructor(oldvalue);
1379                 foundkey = TRUE;
1380             }
1381         }
1382     }
1383     ReleaseSemaphore(&tls_sem);
1384
1385     // tell the parent thread that we are done
1386     Forbid();
1387     inf->finished = TRUE;
1388     Signal(inf->parent, SIGF_PARENT);
1389 }
1390
1391 int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start)(void *), void *arg)
1392 {
1393     ThreadInfo *inf;
1394     char name[NAMELEN];
1395     size_t oldlen;
1396     pthread_t threadnew;
1397
1398     D(bug("%s(%p, %p, %p, %p)\n", __FUNCTION__, thread, attr, start, arg));
1399
1400     if (thread == NULL || start == NULL)
1401         return EINVAL;
1402
1403     ObtainSemaphore(&thread_sem);
1404
1405     // grab an empty thread slot
1406     threadnew = GetThreadId(NULL);
1407     if (threadnew == PTHREAD_THREADS_MAX)
1408     {
1409         ReleaseSemaphore(&thread_sem);
1410         return EAGAIN;
1411     }
1412
1413     // prepare the ThreadInfo structure
1414     inf = GetThreadInfo(threadnew);
1415     memset(inf, 0, sizeof(ThreadInfo));
1416     inf->start = start;
1417     inf->arg = arg;
1418     inf->parent = FindTask(NULL);
1419     if (attr)
1420         inf->attr = *attr;
1421     else
1422         pthread_attr_init(&inf->attr);
1423     NEWLIST((struct List *)&inf->cleanup);
1424     inf->cancelstate = PTHREAD_CANCEL_ENABLE;
1425     inf->canceltype = PTHREAD_CANCEL_DEFERRED;
1426
1427     // let's trick CreateNewProc into allocating a larger buffer for the name
1428     snprintf(name, sizeof(name), "pthread thread #%d", threadnew);
1429     oldlen = strlen(name);
1430     memset(name + oldlen, ' ', sizeof(name) - oldlen - 1);
1431     name[sizeof(name) - 1] = '\0';
1432
1433     // start the child thread
1434     inf->task = (struct Task *)CreateNewProcTags(NP_Entry, StarterFunc,
1435 #ifdef __MORPHOS__
1436         NP_CodeType, CODETYPE_PPC,
1437         (inf->attr.stackaddr == NULL && inf->attr.stacksize > 0) ? NP_PPCStackSize : TAG_IGNORE, inf->attr.stacksize,
1438 #else
1439         (inf->attr.stackaddr == NULL && inf->attr.stacksize > 0) ? NP_StackSize : TAG_IGNORE, inf->attr.stacksize,
1440 #endif
1441         NP_UserData, inf,
1442         NP_Name, name,
1443         TAG_DONE);
1444
1445     if (!inf->task)
1446     {
1447         inf->parent = NULL;
1448         ReleaseSemaphore(&thread_sem);
1449         return EAGAIN;
1450     }
1451
1452     ReleaseSemaphore(&thread_sem);
1453
1454     *thread = threadnew;
1455
1456     return 0;
1457 }
1458
1459 int pthread_detach(pthread_t thread)
1460 {
1461     D(bug("%s(%u) not implemented\n", __FUNCTION__, thread));
1462
1463     return ESRCH;
1464 }
1465
1466 int pthread_join(pthread_t thread, void **value_ptr)
1467 {
1468     ThreadInfo *inf;
1469
1470     D(bug("%s(%u, %p)\n", __FUNCTION__, thread, value_ptr));
1471
1472     inf = GetThreadInfo(thread);
1473
1474     if (inf == NULL || inf->parent == NULL)
1475         return ESRCH;
1476
1477     pthread_testcancel();
1478
1479     while (!inf->finished)
1480         Wait(SIGF_PARENT);
1481
1482     if (value_ptr)
1483         *value_ptr = inf->ret;
1484
1485     ObtainSemaphore(&thread_sem);
1486     memset(inf, 0, sizeof(ThreadInfo));
1487     ReleaseSemaphore(&thread_sem);
1488
1489     return 0;
1490 }
1491
1492 int pthread_equal(pthread_t t1, pthread_t t2)
1493 {
1494     D(bug("%s(%u, %u)\n", __FUNCTION__, t1, t2));
1495
1496     return (t1 == t2);
1497 }
1498
1499 pthread_t pthread_self(void)
1500 {
1501     struct Task *task;
1502     pthread_t thread;
1503
1504     D(bug("%s()\n", __FUNCTION__));
1505
1506     task = FindTask(NULL);
1507     thread = GetThreadId(task);
1508
1509     // add non-pthread processes to our list, so we can handle the main thread
1510     if (thread == PTHREAD_THREADS_MAX)
1511     {
1512         ThreadInfo *inf;
1513
1514         ObtainSemaphore(&thread_sem);
1515         thread = GetThreadId(NULL);
1516         if (thread == PTHREAD_THREADS_MAX)
1517         {
1518             // TODO: pthread_self is supposed to always succeed, but we can fail
1519             // here if we run out of thread slots
1520             // this can only happen if too many non-pthread processes call
1521             // this function
1522             //ReleaseSemaphore(&thread_sem);
1523             //return EAGAIN;
1524             abort();
1525         }
1526         inf = GetThreadInfo(thread);
1527         memset(inf, 0, sizeof(ThreadInfo));
1528         NEWLIST((struct List *)&inf->cleanup);
1529         inf->task = task;
1530         ReleaseSemaphore(&thread_sem);
1531     }
1532
1533     return thread;
1534 }
1535
1536 int pthread_cancel(pthread_t thread)
1537 {
1538     ThreadInfo *inf;
1539
1540     D(bug("%s(%u)\n", __FUNCTION__, thread));
1541
1542     inf = GetThreadInfo(thread);
1543
1544     if (inf == NULL || inf->parent == NULL || inf->canceled == TRUE)
1545         return ESRCH;
1546
1547     inf->canceled = TRUE;
1548
1549     // we might have to cancel the thread immediately
1550     if (inf->canceltype == PTHREAD_CANCEL_ASYNCHRONOUS && inf->cancelstate == PTHREAD_CANCEL_ENABLE)
1551     {
1552         struct Task *task;
1553
1554         task = FindTask(NULL);
1555
1556         if (inf->task == task)
1557             pthread_testcancel(); // cancel ourselves
1558         else
1559             Signal(inf->task, SIGBREAKF_CTRL_C); // trigger the exception handler
1560     }
1561
1562     return 0;
1563 }
1564
1565 int pthread_setcancelstate(int state, int *oldstate)
1566 {
1567     pthread_t thread;
1568     ThreadInfo *inf;
1569
1570     D(bug("%s(%d, %p)\n", __FUNCTION__, state, oldstate));
1571
1572     if (state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE)
1573         return EINVAL;
1574
1575     thread = pthread_self();
1576     inf = GetThreadInfo(thread);
1577
1578     if (oldstate)
1579         *oldstate = inf->cancelstate;
1580
1581     inf->cancelstate = state;
1582
1583     return 0;
1584 }
1585
1586 int pthread_setcanceltype(int type, int *oldtype)
1587 {
1588     pthread_t thread;
1589     ThreadInfo *inf;
1590
1591     D(bug("%s(%d, %p)\n", __FUNCTION__, type, oldtype));
1592
1593     if (type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS)
1594         return EINVAL;
1595
1596     thread = pthread_self();
1597     inf = GetThreadInfo(thread);
1598
1599     if (oldtype)
1600         *oldtype = inf->canceltype;
1601
1602     inf->canceltype = type;
1603
1604     return 0;
1605 }
1606
1607 void pthread_testcancel(void)
1608 {
1609     pthread_t thread;
1610     ThreadInfo *inf;
1611
1612     D(bug("%s()\n", __FUNCTION__));
1613
1614     thread = pthread_self();
1615     inf = GetThreadInfo(thread);
1616
1617     if (inf->canceled && (inf->cancelstate == PTHREAD_CANCEL_ENABLE))
1618         pthread_exit(PTHREAD_CANCELED);
1619 }
1620
1621 void pthread_exit(void *value_ptr)
1622 {
1623     pthread_t thread;
1624     ThreadInfo *inf;
1625     CleanupHandler *handler;
1626
1627     D(bug("%s(%p)\n", __FUNCTION__, value_ptr));
1628
1629     thread = pthread_self();
1630     inf = GetThreadInfo(thread);
1631     inf->ret = value_ptr;
1632
1633     // execute the clean-up handlers
1634     while ((handler = (CleanupHandler *)RemTail((struct List *)&inf->cleanup)))
1635         if (handler->routine)
1636             handler->routine(handler->arg);
1637
1638     longjmp(inf->jmp, 1);
1639 }
1640
1641 static void OnceCleanup(void *arg)
1642 {
1643     pthread_once_t *once_control;
1644
1645     DB2(bug("%s(%p)\n", __FUNCTION__, arg));
1646
1647     once_control = (pthread_once_t *)arg;
1648     pthread_spin_unlock(&once_control->lock);
1649 }
1650
1651 int pthread_once(pthread_once_t *once_control, void (*init_routine)(void))
1652 {
1653     D(bug("%s(%p, %p)\n", __FUNCTION__, once_control, init_routine));
1654
1655     if (once_control == NULL || init_routine == NULL)
1656         return EINVAL;
1657
1658     if (__sync_val_compare_and_swap(&once_control->started, FALSE, TRUE))
1659     {
1660         pthread_spin_lock(&once_control->lock);
1661         if (!once_control->done)
1662         {
1663             pthread_cleanup_push(OnceCleanup, once_control);
1664             (*init_routine)();
1665             pthread_cleanup_pop(0);
1666             once_control->done = TRUE;
1667         }
1668         pthread_spin_unlock(&once_control->lock);
1669     }
1670
1671     return 0;
1672 }
1673
1674 //
1675 // Scheduling functions
1676 //
1677
1678 int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param)
1679 {
1680     ThreadInfo *inf;
1681
1682     D(bug("%s(%u, %d, %p)\n", __FUNCTION__, thread, policy, param));
1683
1684     if (param == NULL)
1685         return EINVAL;
1686
1687     inf = GetThreadInfo(thread);
1688
1689     if (inf == NULL)
1690         return ESRCH;
1691
1692     SetTaskPri(inf->task, param->sched_priority);
1693
1694     return 0;
1695 }
1696
1697 //
1698 // Non-portable functions
1699 //
1700 int pthread_setname_np(pthread_t thread, const char *name)
1701 {
1702     ThreadInfo *inf;
1703     char *currentname;
1704     size_t namelen;
1705
1706     D(bug("%s(%u, %s)\n", __FUNCTION__, thread, name));
1707
1708     if (name == NULL)
1709         return ERANGE;
1710
1711     inf = GetThreadInfo(thread);
1712
1713     if (inf == NULL)
1714         return ERANGE;
1715
1716     currentname = GetNodeName(inf->task);
1717
1718     if (inf->parent == NULL)
1719         namelen = strlen(currentname) + 1;
1720     else
1721         namelen = NAMELEN;
1722
1723     if (strlen(name) + 1 > namelen)
1724         return ERANGE;
1725
1726     strncpy(currentname, name, namelen);
1727
1728     return 0;
1729 }
1730
1731 int pthread_getname_np(pthread_t thread, char *name, size_t len)
1732 {
1733     ThreadInfo *inf;
1734     char *currentname;
1735
1736     D(bug("%s(%u, %p, %u)\n", __FUNCTION__, thread, name, len));
1737
1738     if (name == NULL || len == 0)
1739         return ERANGE;
1740
1741     inf = GetThreadInfo(thread);
1742
1743     if (inf == NULL)
1744         return ERANGE;
1745
1746     currentname = GetNodeName(inf->task);
1747
1748     if (strlen(currentname) + 1 > len)
1749         return ERANGE;
1750
1751     // TODO: partially copy the name?
1752     strncpy(name, currentname, len);
1753
1754     return 0;
1755 }
1756
1757 //
1758 // Cancellation cleanup
1759 //
1760
1761 void pthread_cleanup_push(void (*routine)(void *), void *arg)
1762 {
1763     pthread_t thread;
1764     ThreadInfo *inf;
1765     CleanupHandler *handler;
1766
1767     D(bug("%s(%p, %p)\n", __FUNCTION__, routine, arg));
1768
1769     if (routine == NULL)
1770         return;
1771
1772     handler = malloc(sizeof(CleanupHandler));
1773
1774     if (handler == NULL)
1775         return;
1776
1777     thread = pthread_self();
1778     inf = GetThreadInfo(thread);
1779
1780     handler->routine = routine;
1781     handler->arg = arg;
1782     AddTail((struct List *)&inf->cleanup, (struct Node *)handler);
1783 }
1784
1785 void pthread_cleanup_pop(int execute)
1786 {
1787     pthread_t thread;
1788     ThreadInfo *inf;
1789     CleanupHandler *handler;
1790
1791     D(bug("%s(%d)\n", __FUNCTION__, execute));
1792
1793     thread = pthread_self();
1794     inf = GetThreadInfo(thread);
1795     handler = (CleanupHandler *)RemTail((struct List *)&inf->cleanup);
1796
1797     if (handler && handler->routine && execute)
1798         handler->routine(handler->arg);
1799
1800     free(handler);
1801 }
1802
1803 //
1804 // Signalling
1805 //
1806
1807 int pthread_kill(pthread_t thread, int sig)
1808 {
1809     D(bug("%s(%u, %d) not implemented\n", __FUNCTION__, thread, sig));
1810
1811     return EINVAL;
1812 }
1813
1814 //
1815 // Constructors, destructors
1816 //
1817
1818 static int _Init_Func(void)
1819 {
1820     DB2(bug("%s()\n", __FUNCTION__));
1821
1822     //memset(&threads, 0, sizeof(threads));
1823     InitSemaphore(&thread_sem);
1824     InitSemaphore(&tls_sem);
1825     // reserve ID 0 for the main thread
1826     //pthread_self();
1827
1828     return TRUE;
1829 }
1830
1831 static void _Exit_Func(void)
1832 {
1833 #if 0
1834     pthread_t i;
1835 #endif
1836
1837     DB2(bug("%s()\n", __FUNCTION__));
1838
1839     // wait for the threads?
1840 #if 0
1841     for (i = 0; i < PTHREAD_THREADS_MAX; i++)
1842         pthread_join(i, NULL);
1843 #endif
1844 }
1845
1846 #ifdef __AROS__
1847 ADD2INIT(_Init_Func, 0);
1848 ADD2EXIT(_Exit_Func, 0);
1849 #else
1850 static CONSTRUCTOR_P(_Init_Func, 100)
1851 {
1852     return !_Init_Func();
1853 }
1854
1855 static DESTRUCTOR_P(_Exit_Func, 100)
1856 {
1857     _Exit_Func();
1858 }
1859 #endif