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
  29 #include <string.h>
  30 #include <stdio.h>
  31 #include <signal.h>
  32 #include <stdlib.h>
  33
  34 #include "pthread_intern.h"
  35 #include "debug.h"
  36
  37
  38 //#define USE_ASYNC_CANCEL
  39
  40 ThreadInfo threads[PTHREAD_THREADS_MAX];
  41 struct SignalSemaphore thread_sem;
  42 TLSKey tlskeys[PTHREAD_KEYS_MAX];
  43 struct SignalSemaphore tls_sem;
  44
  45 //
  46 // Helper functions
  47 //
  48
  49 int SemaphoreIsInvalid(struct SignalSemaphore *sem)
  50 {
  51     DB2(bug("%s(%p)\n", __FUNCTION__, sem));
  52
  53     return (!sem || sem->ss_Link.ln_Type != NT_SIGNALSEM || sem->ss_WaitQueue.mlh_Tail != NULL);
  54 }
  55
  56 int SemaphoreIsMine(struct SignalSemaphore *sem)
  57 {
  58     struct Task *me;
  59
  60     DB2(bug("%s(%p)\n", __FUNCTION__, sem));
  61
  62     me = FindTask(NULL);
  63
  64     return (sem && sem->ss_NestCount > 0 && sem->ss_Owner == me);
  65 }
  66
  67 ThreadInfo *GetThreadInfo(pthread_t thread)
  68 {
  69     ThreadInfo *inf = NULL;
  70
  71     DB2(bug("%s(%u)\n", __FUNCTION__, thread));
  72
  73     // TODO: more robust error handling?
  74     if (thread < PTHREAD_THREADS_MAX)
  75         inf = &threads[thread];
  76
  77     return inf;
  78 }
  79
  80 pthread_t GetThreadId(struct Task *task)
  81 {
  82     pthread_t i;
  83
  84     DB2(bug("%s(%p)\n", __FUNCTION__, task));
  85
  86     ObtainSemaphoreShared(&thread_sem);
  87
  88     // First thread id will be 1 so that it is different than default value of pthread_t
  89     for (i = PTHREAD_FIRST_THREAD_ID; i < PTHREAD_THREADS_MAX; i++)
  90     {
  91         if (threads[i].task == task)
  92             break;
  93     }
  94
  95     ReleaseSemaphore(&thread_sem);
  96
  97     return i;
  98 }
  99
 100 #if defined __mc68000__
 101 /* No CAS instruction on m68k */
 102 static int __m68k_sync_val_compare_and_swap(int *v, int o, int n)
 103 {
 104     int ret;
 105
 106     Disable();
 107     if ((*v) == (o))
 108         (*v) = (n);
 109     ret = (*v);
 110     Enable();
 111
 112     return ret;
 113 }
 114 #undef __sync_val_compare_and_swap
 115 #define __sync_val_compare_and_swap(v, o, n) __m68k_sync_val_compare_and_swap(v, o, n)
 116
 117 static int __m68k_sync_lock_test_and_set(int *v, int n)
 118 {
 119     Disable();
 120     (*v) = (n);
 121     Enable();
 122
 123     return n;
 124 }
 125 #undef __sync_lock_test_and_set
 126 #define __sync_lock_test_and_set(v, n) __m68k_sync_lock_test_and_set(v, n)
 127 #undef __sync_lock_release
 128 #define __sync_lock_release(v) __m68k_sync_lock_test_and_set(v, 0)
 129
 130 static inline int __m68k_sync_add_and_fetch(int *v, int n)
 131 {
 132     int ret;
 133
 134     Disable();
 135     (*v) += (n);
 136     ret = (*v);
 137     Enable();
 138
 139     return ret;
 140 }
 141 #undef __sync_add_and_fetch
 142 #define __sync_add_and_fetch(v, n) __m68k_sync_add_and_fetch(v, n)
 143 #undef __sync_sub_and_fetch
 144 #define __sync_sub_and_fetch(v, n) __m68k_sync_add_and_fetch(v, -(n))
 145 #endif
 146
 147 //
 148 // Thread specific data functions
 149 //
 150
 151 int pthread_key_delete(pthread_key_t key)
 152 {
 153     TLSKey *tls;
 154
 155     D(bug("%s(%u)\n", __FUNCTION__, key));
 156
 157     if (key >= PTHREAD_KEYS_MAX)
 158         return EINVAL;
 159
 160     tls = &tlskeys[key];
 161
 162     ObtainSemaphore(&tls_sem);
 163
 164     if (tls->used == FALSE)
 165     {
 166         ReleaseSemaphore(&tls_sem);
 167         return EINVAL;
 168     }
 169
 170     tls->used = FALSE;
 171     tls->destructor = NULL;
 172
 173     ReleaseSemaphore(&tls_sem);
 174
 175     return 0;
 176 }
 177
 178 //
 179 // Mutex attribute functions
 180 //
 181
 182 int pthread_mutexattr_gettype(pthread_mutexattr_t *attr, int *kind)
 183 {
 184     D(bug("%s(%p, %p)\n", __FUNCTION__, attr, kind));
 185
 186     if (attr == NULL)
 187         return EINVAL;
 188
 189     if (kind)
 190         *kind = attr->kind;
 191
 192     return 0;
 193 }
 194
 195 //
 196 // Mutex functions
 197 //
 198
 199 int pthread_mutex_timedlock(pthread_mutex_t *mutex, const struct timespec *abstime)
 200 {
 201     struct timeval end, now;
 202     int result;
 203
 204     D(bug("%s(%p, %p)\n", __FUNCTION__, mutex, abstime));
 205
 206     if (mutex == NULL)
 207         return EINVAL;
 208
 209     if (abstime == NULL)
 210         return pthread_mutex_lock(mutex);
 211     /*else if (abstime.tv_nsec < 0 || abstime.tv_nsec >= 1000000000)
 212         return EINVAL;*/
 213
 214     TIMESPEC_TO_TIMEVAL(&end, abstime);
 215
 216     // busy waiting is not very nice, but ObtainSemaphore doesn't support timeouts
 217     while ((result = pthread_mutex_trylock(mutex)) == EBUSY)
 218     {
 219         sched_yield();
 220         gettimeofday(&now, NULL);
 221         if (timercmp(&end, &now, <))
 222             return ETIMEDOUT;
 223     }
 224
 225     return result;
 226 }
 227
 228 //
 229 // Condition variable attribute functions
 230 //
 231
 232 int pthread_condattr_init(pthread_condattr_t *attr)
 233 {
 234     D(bug("%s(%p)\n", __FUNCTION__, attr));
 235
 236     if (attr == NULL)
 237         return EINVAL;
 238
 239     memset(attr, 0, sizeof(pthread_condattr_t));
 240
 241     return 0;
 242 }
 243
 244 int pthread_condattr_destroy(pthread_condattr_t *attr)
 245 {
 246     D(bug("%s(%p)\n", __FUNCTION__, attr));
 247
 248     if (attr == NULL)
 249         return EINVAL;
 250
 251     memset(attr, 0, sizeof(pthread_condattr_t));
 252
 253     return 0;
 254 }
 255
 256 //
 257 // Condition variable functions
 258 //
 259
 260 int pthread_cond_timedwait_relative_np(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *reltime)
 261 {
 262     D(bug("%s(%p, %p, %p)\n", __FUNCTION__, cond, mutex, reltime));
 263
 264     return _pthread_cond_timedwait(cond, mutex, reltime, TRUE);
 265 }
 266
 267
 268 //
 269 // Barrier functions
 270 //
 271
 272 int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count)
 273 {
 274     D(bug("%s(%p, %p, %u)\n", __FUNCTION__, barrier, attr, count));
 275
 276     if (barrier == NULL || count == 0)
 277         return EINVAL;
 278
 279     barrier->curr_height = count;
 280     barrier->total_height = PTHREAD_BARRIER_FLAG;
 281     pthread_cond_init(&barrier->breeched, NULL);
 282     pthread_mutex_init(&barrier->lock, NULL);
 283
 284     return 0;
 285 }
 286
 287 int pthread_barrier_destroy(pthread_barrier_t *barrier)
 288 {
 289     D(bug("%s(%p)\n", __FUNCTION__, barrier));
 290
 291     if (barrier == NULL)
 292         return EINVAL;
 293
 294     if (pthread_mutex_trylock(&barrier->lock) != 0)
 295         return EBUSY;
 296
 297     if (barrier->total_height > PTHREAD_BARRIER_FLAG)
 298     {
 299         pthread_mutex_unlock(&barrier->lock);
 300         return EBUSY;
 301     }
 302
 303     pthread_mutex_unlock(&barrier->lock);
 304
 305     if (pthread_cond_destroy(&barrier->breeched) != 0)
 306         return EBUSY;
 307
 308     pthread_mutex_destroy(&barrier->lock);
 309     barrier->curr_height = barrier->total_height = 0;
 310
 311     return 0;
 312 }
 313
 314 int pthread_barrier_wait(pthread_barrier_t *barrier)
 315 {
 316     D(bug("%s(%p)\n", __FUNCTION__, barrier));
 317
 318     if (barrier == NULL)
 319         return EINVAL;
 320
 321     pthread_mutex_lock(&barrier->lock);
 322
 323     // wait until everyone exits the barrier
 324     while (barrier->total_height > PTHREAD_BARRIER_FLAG)
 325         pthread_cond_wait(&barrier->breeched, &barrier->lock);
 326
 327     // are we the first to enter?
 328     if (barrier->total_height == PTHREAD_BARRIER_FLAG) barrier->total_height = 0;
 329
 330     barrier->total_height++;
 331
 332     if (barrier->total_height == barrier->curr_height)
 333     {
 334         barrier->total_height += PTHREAD_BARRIER_FLAG - 1;
 335         pthread_cond_broadcast(&barrier->breeched);
 336
 337         pthread_mutex_unlock(&barrier->lock);
 338
 339         return PTHREAD_BARRIER_SERIAL_THREAD;
 340     }
 341     else
 342     {
 343         // wait until enough threads enter the barrier
 344         while (barrier->total_height < PTHREAD_BARRIER_FLAG)
 345             pthread_cond_wait(&barrier->breeched, &barrier->lock);
 346
 347         barrier->total_height--;
 348
 349         // get entering threads to wake up
 350         if (barrier->total_height == PTHREAD_BARRIER_FLAG)
 351             pthread_cond_broadcast(&barrier->breeched);
 352
 353         pthread_mutex_unlock(&barrier->lock);
 354
 355         return 0;
 356     }
 357 }
 358
 359 //
 360 // Read-write lock attribute functions
 361 //
 362
 363 int pthread_rwlockattr_init(pthread_rwlockattr_t *attr)
 364 {
 365     D(bug("%s(%p)\n", __FUNCTION__, attr));
 366
 367     if (attr == NULL)
 368         return EINVAL;
 369
 370     memset(attr, 0, sizeof(pthread_rwlockattr_t));
 371
 372     return 0;
 373 }
 374
 375 int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr)
 376 {
 377     D(bug("%s(%p)\n", __FUNCTION__, attr));
 378
 379     if (attr == NULL)
 380         return EINVAL;
 381
 382     memset(attr, 0, sizeof(pthread_rwlockattr_t));
 383
 384     return 0;
 385 }
 386
 387 //
 388 // Read-write lock functions
 389 //
 390
 391 int pthread_rwlock_init(pthread_rwlock_t *lock, const pthread_rwlockattr_t *attr)
 392 {
 393     D(bug("%s(%p, %p)\n", __FUNCTION__, lock, attr));
 394
 395     if (lock == NULL)
 396         return EINVAL;
 397
 398     InitSemaphore(&lock->semaphore);
 399
 400     return 0;
 401 }
 402
 403 int pthread_rwlock_destroy(pthread_rwlock_t *lock)
 404 {
 405     D(bug("%s(%p)\n", __FUNCTION__, lock));
 406
 407     if (lock == NULL)
 408         return EINVAL;
 409
 410     // probably a statically allocated rwlock
 411     if (SemaphoreIsInvalid(&lock->semaphore))
 412         return 0;
 413
 414     if (AttemptSemaphore(&lock->semaphore) == FALSE)
 415         return EBUSY;
 416
 417     ReleaseSemaphore(&lock->semaphore);
 418     memset(lock, 0, sizeof(pthread_rwlock_t));
 419
 420     return 0;
 421 }
 422
 423 int pthread_rwlock_tryrdlock(pthread_rwlock_t *lock)
 424 {
 425     ULONG ret;
 426
 427     D(bug("%s(%p)\n", __FUNCTION__, lock));
 428
 429     if (lock == NULL)
 430         return EINVAL;
 431
 432     // initialize static rwlocks
 433     if (SemaphoreIsInvalid(&lock->semaphore))
 434         pthread_rwlock_init(lock, NULL);
 435
 436     ret = AttemptSemaphoreShared(&lock->semaphore);
 437
 438     return (ret == TRUE) ? 0 : EBUSY;
 439 }
 440
 441 int pthread_rwlock_trywrlock(pthread_rwlock_t *lock)
 442 {
 443     ULONG ret;
 444
 445     D(bug("%s(%p)\n", __FUNCTION__, lock));
 446
 447     if (lock == NULL)
 448         return EINVAL;
 449
 450     // initialize static rwlocks
 451     if (SemaphoreIsInvalid(&lock->semaphore))
 452         pthread_rwlock_init(lock, NULL);
 453
 454     ret = AttemptSemaphore(&lock->semaphore);
 455
 456     return (ret == TRUE) ? 0 : EBUSY;
 457 }
 458
 459 int pthread_rwlock_rdlock(pthread_rwlock_t *lock)
 460 {
 461     D(bug("%s(%p)\n", __FUNCTION__, lock));
 462
 463     if (lock == NULL)
 464         return EINVAL;
 465
 466     pthread_testcancel();
 467
 468     // initialize static rwlocks
 469     if (SemaphoreIsInvalid(&lock->semaphore))
 470         pthread_rwlock_init(lock, NULL);
 471
 472     // we might already have a write lock
 473     if (SemaphoreIsMine(&lock->semaphore))
 474         return EDEADLK;
 475
 476     ObtainSemaphoreShared(&lock->semaphore);
 477
 478     return 0;
 479 }
 480
 481 int pthread_rwlock_timedrdlock(pthread_rwlock_t *lock, const struct timespec *abstime)
 482 {
 483     struct timeval end, now;
 484     int result;
 485
 486     D(bug("%s(%p, %p)\n", __FUNCTION__, lock, abstime));
 487
 488     if (lock == NULL)
 489         return EINVAL;
 490
 491     if (abstime == NULL)
 492         return pthread_rwlock_rdlock(lock);
 493
 494     pthread_testcancel();
 495
 496     TIMESPEC_TO_TIMEVAL(&end, abstime);
 497
 498     // busy waiting is not very nice, but ObtainSemaphore doesn't support timeouts
 499     while ((result = pthread_rwlock_tryrdlock(lock)) == EBUSY)
 500     {
 501         sched_yield();
 502         gettimeofday(&now, NULL);
 503         if (timercmp(&end, &now, <))
 504             return ETIMEDOUT;
 505     }
 506
 507     return result;
 508 }
 509
 510 int pthread_rwlock_wrlock(pthread_rwlock_t *lock)
 511 {
 512     D(bug("%s(%p)\n", __FUNCTION__, lock));
 513
 514     if (lock == NULL)
 515         return EINVAL;
 516
 517     pthread_testcancel();
 518
 519     // initialize static rwlocks
 520     if (SemaphoreIsInvalid(&lock->semaphore))
 521         pthread_rwlock_init(lock, NULL);
 522
 523     if (SemaphoreIsMine(&lock->semaphore))
 524         return EDEADLK;
 525
 526     ObtainSemaphore(&lock->semaphore);
 527
 528     return 0;
 529 }
 530
 531 int pthread_rwlock_timedwrlock(pthread_rwlock_t *lock, const struct timespec *abstime)
 532 {
 533     struct timeval end, now;
 534     int result;
 535
 536     D(bug("%s(%p, %p)\n", __FUNCTION__, lock, abstime));
 537
 538     if (lock == NULL)
 539         return EINVAL;
 540
 541     if (abstime == NULL)
 542         return pthread_rwlock_wrlock(lock);
 543
 544     pthread_testcancel();
 545
 546     TIMESPEC_TO_TIMEVAL(&end, abstime);
 547
 548     // busy waiting is not very nice, but ObtainSemaphore doesn't support timeouts
 549     while ((result = pthread_rwlock_trywrlock(lock)) == EBUSY)
 550     {
 551         sched_yield();
 552         gettimeofday(&now, NULL);
 553         if (timercmp(&end, &now, <))
 554             return ETIMEDOUT;
 555     }
 556
 557     return result;
 558 }
 559
 560 int pthread_rwlock_unlock(pthread_rwlock_t *lock)
 561 {
 562     D(bug("%s(%p)\n", __FUNCTION__, lock));
 563
 564     if (lock == NULL)
 565         return EINVAL;
 566
 567     // initialize static rwlocks
 568     if (SemaphoreIsInvalid(&lock->semaphore))
 569         pthread_rwlock_init(lock, NULL);
 570
 571     //if (!SemaphoreIsMine(&lock->semaphore))
 572     // if no one has obtained the semaphore don't unlock the rwlock
 573     // this can be a leap of faith because we don't maintain a separate list of readers
 574     if (lock->semaphore.ss_NestCount < 1)
 575         return EPERM;
 576
 577     ReleaseSemaphore(&lock->semaphore);
 578
 579     return 0;
 580 }
 581
 582 //
 583 // Spinlock functions
 584 //
 585
 586 int pthread_spin_init(pthread_spinlock_t *lock, int pshared)
 587 {
 588     D(bug("%s(%p, %d)\n", __FUNCTION__, lock, pshared));
 589
 590     if (lock == NULL)
 591         return EINVAL;
 592
 593     *lock = 0;
 594
 595     return 0;
 596 }
 597
 598 int pthread_spin_destroy(pthread_spinlock_t *lock)
 599 {
 600     D(bug("%s(%p)\n", __FUNCTION__, lock));
 601
 602     return 0;
 603 }
 604
 605 int pthread_spin_lock(pthread_spinlock_t *lock)
 606 {
 607     D(bug("%s(%p)\n", __FUNCTION__, lock));
 608
 609     if (lock == NULL)
 610         return EINVAL;
 611
 612     while (__sync_lock_test_and_set((int *)lock, 1))
 613         sched_yield(); // TODO: don't yield the CPU every iteration
 614
 615     return 0;
 616 }
 617
 618 int pthread_spin_trylock(pthread_spinlock_t *lock)
 619 {
 620     D(bug("%s(%p)\n", __FUNCTION__, lock));
 621
 622     if (lock == NULL)
 623         return EINVAL;
 624
 625     if (__sync_lock_test_and_set((int *)lock, 1))
 626         return EBUSY;
 627
 628     return 0;
 629 }
 630
 631 int pthread_spin_unlock(pthread_spinlock_t *lock)
 632 {
 633     D(bug("%s(%p)\n", __FUNCTION__, lock));
 634
 635     if (lock == NULL)
 636         return EINVAL;
 637
 638     __sync_lock_release((int *)lock);
 639
 640     return 0;
 641 }
 642
 643 //
 644 // Thread attribute functions
 645 //
 646
 647 int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
 648 {
 649     D(bug("%s(%p, %p)\n", __FUNCTION__, attr, detachstate));
 650
 651     if (attr == NULL)
 652         return EINVAL;
 653
 654     if (detachstate != NULL)
 655         *detachstate = attr->detachstate;
 656
 657     return 0;
 658 }
 659
 660 int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
 661 {
 662     D(bug("%s(%p, %d)\n", __FUNCTION__, attr, detachstate));
 663
 664     if (attr == NULL || detachstate != PTHREAD_CREATE_JOINABLE)
 665         return EINVAL;
 666
 667     attr->detachstate = detachstate;
 668
 669     return 0;
 670 }
 671
 672 int pthread_attr_getstack(const pthread_attr_t *attr, void **stackaddr, size_t *stacksize)
 673 {
 674     D(bug("%s(%p, %p, %p)\n", __FUNCTION__, attr, stackaddr, stacksize));
 675
 676     if (attr == NULL)
 677         return EINVAL;
 678
 679     if (stackaddr != NULL)
 680         *stackaddr = attr->stackaddr;
 681
 682     if (stacksize != NULL)
 683         *stacksize = attr->stacksize;
 684
 685     return 0;
 686 }
 687
 688 int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr, size_t stacksize)
 689 {
 690     D(bug("%s(%p, %p, %u)\n", __FUNCTION__, attr, stackaddr, stacksize));
 691
 692     if (attr == NULL || (stackaddr != NULL && stacksize == 0))
 693         return EINVAL;
 694
 695     attr->stackaddr = stackaddr;
 696     attr->stacksize = stacksize;
 697
 698     return 0;
 699 }
 700
 701 int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize)
 702 {
 703     D(bug("%s(%p, %p)\n", __FUNCTION__, attr, stacksize));
 704
 705     return pthread_attr_getstack(attr, NULL, stacksize);
 706 }
 707
 708 int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param)
 709 {
 710     D(bug("%s(%p, %p)\n", __FUNCTION__, attr, param));
 711
 712     if (attr == NULL)
 713         return EINVAL;
 714
 715     if (param != NULL)
 716         *param = attr->param;
 717
 718     return 0;
 719 }
 720
 721 int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param)
 722 {
 723     D(bug("%s(%p, %p)\n", __FUNCTION__, attr, param));
 724
 725     if (attr == NULL || param == NULL)
 726         return EINVAL;
 727
 728     attr->param = *param;
 729
 730     return 0;
 731 }
 732
 733 //
 734 // Thread functions
 735 //
 736
 737 #ifdef USE_ASYNC_CANCEL
 738 #ifdef __MORPHOS__
 739 static ULONG CancelHandlerFunc(void);
 740 static struct EmulLibEntry CancelHandler =
 741 {
 742     TRAP_LIB, 0, (void (*)(void))CancelHandlerFunc
 743 };
 744 static ULONG CancelHandlerFunc(void)
 745 {
 746     ULONG signals = (ULONG)REG_D0;
 747     APTR data = (APTR)REG_A1;
 748     struct ExecBase *SysBase = (struct ExecBase *)REG_A6;
 749 #else
 750 AROS_UFH3S(ULONG, CancelHandler,
 751     AROS_UFHA(ULONG, signals, D0),
 752     AROS_UFHA(APTR, data, A1),
 753     AROS_UFHA(struct ExecBase *, SysBase, A6))
 754 {
 755     AROS_USERFUNC_INIT
 756 #endif
 757
 758     DB2(bug("%s(%u, %p, %p)\n", __FUNCTION__, signals, data, SysBase));
 759
 760     pthread_testcancel();
 761
 762     return signals;
 763 #ifdef __AROS__
 764     AROS_USERFUNC_EXIT
 765 #endif
 766 }
 767 #endif
 768
 769 int pthread_detach(pthread_t thread)
 770 {
 771     ThreadInfo *inf;
 772
 773     D(bug("%s(%u, %p)\n", __FUNCTION__, thread, value_ptr));
 774
 775     inf = GetThreadInfo(thread);
 776
 777     if (inf == NULL)
 778         return ESRCH;
 779
 780     inf->detached = TRUE;
 781
 782     return 0;
 783 }
 784
 785 void pthread_testcancel(void)
 786 {
 787     pthread_t thread;
 788     ThreadInfo *inf;
 789
 790     D(bug("%s()\n", __FUNCTION__));
 791
 792     thread = pthread_self();
 793     inf = GetThreadInfo(thread);
 794
 795     if (inf->canceled && (inf->cancelstate == PTHREAD_CANCEL_ENABLE))
 796         pthread_exit(PTHREAD_CANCELED);
 797 }
 798
 799 static void OnceCleanup(void *arg)
 800 {
 801     pthread_once_t *once_control;
 802
 803     DB2(bug("%s(%p)\n", __FUNCTION__, arg));
 804
 805     once_control = (pthread_once_t *)arg;
 806     pthread_spin_unlock(&once_control->lock);
 807 }
 808
 809 int pthread_once(pthread_once_t *once_control, void (*init_routine)(void))
 810 {
 811     D(bug("%s(%p, %p)\n", __FUNCTION__, once_control, init_routine));
 812
 813     if (once_control == NULL || init_routine == NULL)
 814         return EINVAL;
 815
 816     if (__sync_val_compare_and_swap(&once_control->started, FALSE, TRUE))
 817     {
 818         pthread_spin_lock(&once_control->lock);
 819         if (!once_control->done)
 820         {
 821             pthread_cleanup_push(OnceCleanup, once_control);
 822             (*init_routine)();
 823             pthread_cleanup_pop(0);
 824             once_control->done = TRUE;
 825         }
 826         pthread_spin_unlock(&once_control->lock);
 827     }
 828
 829     return 0;
 830 }
 831
 832 //
 833 // Scheduling functions
 834 //
 835
 836 int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param)
 837 {
 838     ThreadInfo *inf;
 839
 840     D(bug("%s(%u, %d, %p)\n", __FUNCTION__, thread, policy, param));
 841
 842     if (param == NULL)
 843         return EINVAL;
 844
 845     inf = GetThreadInfo(thread);
 846
 847     if (inf == NULL)
 848         return ESRCH;
 849
 850     SetTaskPri(inf->task, param->sched_priority);
 851
 852     return 0;
 853 }
 854
 855 int pthread_getschedparam(pthread_t thread, int *policy, struct sched_param *param)
 856 {
 857     ThreadInfo *inf;
 858
 859     D(bug("%s(%u, %d, %p)\n", __FUNCTION__, thread, policy, param));
 860
 861     if ((param == NULL) || (policy == NULL))
 862         return EINVAL;
 863
 864     inf = GetThreadInfo(thread);
 865
 866     if (inf == NULL)
 867         return ESRCH;
 868
 869     param->sched_priority = inf->task->tc_Node.ln_Pri;
 870     *policy = 1;
 871
 872     return 0;
 873 }
 874
 875 //
 876 // Non-portable functions
 877 //
 878 int pthread_setname_np(pthread_t thread, const char *name)
 879 {
 880     ThreadInfo *inf;
 881     char *currentname;
 882     size_t namelen;
 883
 884     D(bug("%s(%u, %s)\n", __FUNCTION__, thread, name));
 885
 886     if (name == NULL)
 887         return ERANGE;
 888
 889     inf = GetThreadInfo(thread);
 890
 891     if (inf == NULL)
 892         return ERANGE;
 893
 894     currentname = GetNodeName(inf->task);
 895
 896     if (inf->parent == NULL)
 897         namelen = strlen(currentname) + 1;
 898     else
 899         namelen = NAMELEN;
 900
 901     if (strlen(name) + 1 > namelen)
 902         return ERANGE;
 903
 904     strncpy(currentname, name, namelen);
 905
 906     return 0;
 907 }
 908
 909 int pthread_getname_np(pthread_t thread, char *name, size_t len)
 910 {
 911     ThreadInfo *inf;
 912     char *currentname;
 913
 914     D(bug("%s(%u, %p, %u)\n", __FUNCTION__, thread, name, len));
 915
 916     if (name == NULL || len == 0)
 917         return ERANGE;
 918
 919     inf = GetThreadInfo(thread);
 920
 921     if (inf == NULL)
 922         return ERANGE;
 923
 924     currentname = GetNodeName(inf->task);
 925
 926     if (strlen(currentname) + 1 > len)
 927         return ERANGE;
 928
 929     // TODO: partially copy the name?
 930     strncpy(name, currentname, len);
 931
 932     return 0;
 933 }
 934
 935 //
 936 // Cancellation cleanup
 937 //
 938
 939 void pthread_cleanup_push(void (*routine)(void *), void *arg)
 940 {
 941     pthread_t thread;
 942     ThreadInfo *inf;
 943     CleanupHandler *handler;
 944
 945     D(bug("%s(%p, %p)\n", __FUNCTION__, routine, arg));
 946
 947     if (routine == NULL)
 948         return;
 949
 950     handler = malloc(sizeof(CleanupHandler));
 951
 952     if (handler == NULL)
 953         return;
 954
 955     thread = pthread_self();
 956     inf = GetThreadInfo(thread);
 957
 958     handler->routine = routine;
 959     handler->arg = arg;
 960     AddTail((struct List *)&inf->cleanup, (struct Node *)handler);
 961 }
 962
 963 void pthread_cleanup_pop(int execute)
 964 {
 965     pthread_t thread;
 966     ThreadInfo *inf;
 967     CleanupHandler *handler;
 968
 969     D(bug("%s(%d)\n", __FUNCTION__, execute));
 970
 971     thread = pthread_self();
 972     inf = GetThreadInfo(thread);
 973     handler = (CleanupHandler *)RemTail((struct List *)&inf->cleanup);
 974
 975     if (handler && handler->routine && execute)
 976         handler->routine(handler->arg);
 977
 978     free(handler);
 979 }
 980
 981 //
 982 // Signalling
 983 //
 984
 985 int pthread_kill(pthread_t thread, int sig)
 986 {
 987     D(bug("%s(%u, %d) not implemented\n", __FUNCTION__, thread, sig));
 988
 989     return EINVAL;
 990 }
 991
 992 //
 993 // Constructors, destructors
 994 //
 995
 996 static int _Init_Func(void)
 997 {
 998     DB2(bug("%s()\n", __FUNCTION__));
 999
1000     //memset(&threads, 0, sizeof(threads));
1001     InitSemaphore(&thread_sem);
1002     InitSemaphore(&tls_sem);
1003     // reserve ID 0 for the main thread
1004     //pthread_self();
1005
1006     return TRUE;
1007 }
1008
1009 static void _Exit_Func(void)
1010 {
1011 #if 0
1012     pthread_t i;
1013 #endif
1014
1015     DB2(bug("%s()\n", __FUNCTION__));
1016
1017     // wait for the threads?
1018 #if 0
1019     for (i = 0; i < PTHREAD_THREADS_MAX; i++)
1020         pthread_join(i, NULL);
1021 #endif
1022 }
1023
1024 #ifdef __AROS__
1025 ADD2INIT(_Init_Func, 0);
1026 ADD2EXIT(_Exit_Func, 0);
1027 #else
1028 static CONSTRUCTOR_P(_Init_Func, 100)
1029 {
1030     return !_Init_Func();
1031 }
1032
1033 static DESTRUCTOR_P(_Exit_Func, 100)
1034 {
1035     _Exit_Func();
1036 }
1037 #endif