rx: Remove RX_CALL_BUSY
[openafs.git] / src / WINNT / pthread / pthread.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  * This file contains a skeleton pthread implementation for NT.
12  * This is not intended to be a fully compliant pthread implementation
13  * The purpose of this file is to only implement those functions that
14  * are truly needed to support the afs code base.
15  *
16  * A secondary goal is to allow a "real" pthread implementation to
17  * replace this file without any modification to code that depends upon
18  * this file
19  *
20  * The function signatures and argument types are meant to be the same
21  * as their UNIX prototypes.
22  * Where possible, the POSIX specified return values are used.
23  * For situations where an error can occur, but no corresponding
24  * POSIX error value exists, unique (within a given function) negative
25  * numbers are used for errors to avoid collsions with the errno
26  * style values.
27  */
28
29 #include <afs/param.h>
30 #include <afs/stds.h>
31
32 #include <pthread.h>
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <string.h>
36 #include <process.h>
37 #include <errno.h>
38 #include <sys/timeb.h>
39
40 #define PTHREAD_EXIT_EXCEPTION 0x1
41
42 /*
43  * Posix threads uses static initialization for pthread_once control
44  * objects, and under NT, every sophisticated synchronization primitive
45  * uses procedural initialization.  This forces the use of CompareExchange
46  * (aka test and set) and busy waiting for threads that compete to run
47  * a pthread_once'd function.  We make these "busy" threads give up their
48  * timeslice - which should cause acceptable behavior on a single processor
49  * machine, but on a multiprocessor machine this could very well result
50  * in busy waiting.
51  */
52
53 int pthread_once(pthread_once_t *once_control, void (*init_routine)(void)) {
54     int rc = 0;
55
56     if ((once_control != NULL) && (init_routine != NULL)) {
57         if (InterlockedExchange((LPLONG)&once_control->call_started,
58                                 (LONG) 1) == 0) {
59             (*init_routine)();
60             once_control->call_running = 0;
61         } else {
62             /* use Sleep() since SwitchToThread() not available on Win95 */
63             while(once_control->call_running) Sleep(20);
64         }
65     } else {
66         rc = EINVAL;
67     }
68     return rc;
69 }
70
71 /*
72  * For now only support PTHREAD_PROCESS_PRIVATE mutexes.
73  * if PTHREAD_PROCESS_SHARED are required later they can be added
74  */
75
76 int pthread_mutex_init(pthread_mutex_t *mp, const pthread_mutexattr_t *attr) {
77     int rc = 0;
78
79     if ((mp != NULL) && (attr == NULL)) {
80         memset(mp, 0, sizeof(*mp));
81         InitializeCriticalSection(&mp->cs);
82         mp->isLocked = 0;
83         mp->tid = 0;
84     } else {
85         rc = EINVAL;
86     }
87     return rc;
88 }
89
90 /*
91  * Under NT, critical sections can be locked recursively by the owning
92  * thread.  This is opposite of the pthread spec, and so we keep track
93  * of the thread that has locked a critical section.  If the same thread
94  * tries to lock a critical section more than once we fail.
95  */
96 int pthread_mutex_trylock(pthread_mutex_t *mp) {
97     int rc = 0;
98
99 #ifdef AFS_WIN95_ENV
100     /* TryEnterCriticalSection() not available on Win95, so just wait for
101      * the lock.  Correct code generally can't depend on how long the
102      * function takes to return, so the only code that will be broken is
103      * that for which 1) the mutex *mp is obtained and never released or
104      * 2) the mutex *mp is intentionally held until trylock() returns.
105      * These cases are unusual and don't appear in normal (non-test) AFS
106      * code; furthermore, we can reduce (but not eliminate!) the problem by
107      * sneaking a look at isLocked even though we don't hold the
108      * CRITICAL_SECTION in mutex *mp and are thus vulnerable to race
109      * conditions.  Note that self-deadlock isn't a problem since
110      * CRITICAL_SECTION objects are recursive.
111      *
112      * Given the very restricted usage of the pthread library on Windows 95,
113      * we can live with these limitations.
114      */
115     if (mp != NULL) {
116         if (mp->isLocked) {
117             rc = EBUSY;
118         } else {
119             rc = pthread_mutex_lock(mp);
120         }
121     } else {
122         rc = EINVAL;
123     }
124 #else
125     /* TryEnterCriticalSection() provided on other MS platforms of interest */
126     if (mp != NULL) {
127         if (TryEnterCriticalSection(&mp->cs)) {
128             if (mp->isLocked) {
129                 /* same thread tried to recursively lock, fail */
130                 LeaveCriticalSection(&mp->cs);
131                 rc = EDEADLK;
132             } else {
133                 mp->isLocked = 1;
134                 mp->tid = GetCurrentThreadId();
135                 rc = 0;
136             }
137         } else {
138             rc = EBUSY;
139         }
140     } else {
141         rc = EINVAL;
142     }
143 #endif /* AFS_WIN95_ENV */
144
145     return rc;
146 }
147
148
149 int pthread_mutex_lock(pthread_mutex_t *mp) {
150     int rc = 0;
151
152     if (mp != NULL) {
153         EnterCriticalSection(&mp->cs);
154         if (!mp->isLocked) {
155             mp->isLocked = 1;
156             mp->tid = GetCurrentThreadId();
157         } else {
158             /*
159              * same thread tried to recursively lock this mutex.
160              * Under real POSIX, this would cause a deadlock, but NT only
161              * supports recursive mutexes so we indicate the situation
162              * by returning EDEADLK.
163              */
164             LeaveCriticalSection(&mp->cs);
165             rc = EDEADLK;
166 #ifdef PTHREAD_DEBUG
167             DebugBreak();
168 #endif
169         }
170     } else {
171 #ifdef PTHREAD_DEBUG
172         DebugBreak();
173 #endif
174         rc = EINVAL;
175     }
176
177     return rc;
178 }
179
180 int pthread_mutex_unlock(pthread_mutex_t *mp) {
181     int rc = 0;
182
183     if (mp != NULL) {
184         if (mp->tid == GetCurrentThreadId()) {
185             mp->isLocked = 0;
186             mp->tid = 0;
187             LeaveCriticalSection(&mp->cs);
188         } else {
189 #ifdef PTHREAD_DEBUG
190             DebugBreak();
191 #endif
192             rc = EPERM;
193         }
194     } else {
195 #ifdef PTHREAD_DEBUG
196         DebugBreak();
197 #endif
198         rc = EINVAL;
199     }
200     return rc;
201 }
202
203 int pthread_mutex_destroy(pthread_mutex_t *mp) {
204     int rc = 0;
205
206     if (mp != NULL) {
207         DeleteCriticalSection(&mp->cs);
208     } else {
209 #ifdef PTHREAD_DEBUG
210         DebugBreak();
211 #endif
212         rc = EINVAL;
213     }
214
215     return rc;
216 }
217
218 int pthread_rwlock_destroy(pthread_rwlock_t *rwp)
219 {
220     int rc = 0;
221
222     if (rwp != NULL) {
223         pthread_mutex_destroy(&rwp->read_access_completion_mutex);
224         pthread_mutex_destroy(&rwp->write_access_mutex);
225         pthread_cond_destroy(&rwp->read_access_completion_wait);
226     } else {
227 #ifdef PTHREAD_DEBUG
228         DebugBreak();
229 #endif
230         rc = EINVAL;
231     }
232
233     return rc;
234 }
235
236 int pthread_rwlock_init(pthread_rwlock_t *rwp, const pthread_rwlockattr_t *attr)
237 {
238     int rc = 0;
239
240     if (rwp == NULL)
241         return EINVAL;
242
243     rwp->readers = 0;
244
245     rc = pthread_mutex_init(&rwp->write_access_mutex, NULL);
246     if (rc)
247         return rc;
248
249     rc = pthread_mutex_init(&rwp->read_access_completion_mutex, NULL);
250     if (rc)
251         goto error1;
252
253     rc = pthread_cond_init(&rwp->read_access_completion_wait, NULL);
254     if (rc == 0)
255         return 0;       /* success */
256
257     pthread_mutex_destroy(&rwp->read_access_completion_mutex);
258
259   error1:
260     pthread_mutex_destroy(&rwp->write_access_mutex);
261
262     return rc;
263 }
264
265 int pthread_rwlock_wrlock(pthread_rwlock_t *rwp)
266 {
267     int rc = 0;
268
269     if (rwp == NULL)
270         return EINVAL;
271
272     if ((rc = pthread_mutex_lock(&rwp->write_access_mutex)) != 0)
273         return rc;
274
275     if ((rc = pthread_mutex_lock(&rwp->read_access_completion_mutex)) != 0)
276     {
277         pthread_mutex_unlock(&rwp->write_access_mutex);
278         return rc;
279     }
280
281     while (rc == 0 && rwp->readers > 0) {
282         rc = pthread_cond_wait( &rwp->read_access_completion_wait,
283                                 &rwp->read_access_completion_mutex);
284     }
285
286     pthread_mutex_unlock(&rwp->read_access_completion_mutex);
287
288     if (rc)
289         pthread_mutex_unlock(&rwp->write_access_mutex);
290
291     return rc;
292 }
293
294 int pthread_rwlock_rdlock(pthread_rwlock_t *rwp)
295 {
296     int rc = 0;
297
298     if (rwp == NULL)
299         return EINVAL;
300
301     if ((rc = pthread_mutex_lock(&rwp->write_access_mutex)) != 0)
302         return rc;
303
304     if ((rc = pthread_mutex_lock(&rwp->read_access_completion_mutex)) != 0)
305     {
306         pthread_mutex_unlock(&rwp->write_access_mutex);
307         return rc;
308     }
309
310     rwp->readers++;
311
312     pthread_mutex_unlock(&rwp->read_access_completion_mutex);
313
314     pthread_mutex_unlock(&rwp->write_access_mutex);
315
316     return rc;
317
318 }
319
320 int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwp)
321 {
322     int rc = 0;
323
324     if (rwp == NULL)
325         return EINVAL;
326
327     if ((rc = pthread_mutex_trylock(&rwp->write_access_mutex)) != 0)
328         return rc;
329
330     if ((rc = pthread_mutex_trylock(&rwp->read_access_completion_mutex)) != 0) {
331         pthread_mutex_unlock(&rwp->write_access_mutex);
332         return rc;
333     }
334
335     rwp->readers++;
336
337     pthread_mutex_unlock(&rwp->read_access_completion_mutex);
338
339     pthread_mutex_unlock(&rwp->write_access_mutex);
340
341     return rc;
342 }
343
344 int pthread_rwlock_trywrlock(pthread_rwlock_t *rwp)
345 {
346     int rc = 0;
347
348     if (rwp == NULL)
349         return EINVAL;
350
351     if ((rc = pthread_mutex_trylock(&rwp->write_access_mutex)) != 0)
352         return rc;
353
354     if ((rc = pthread_mutex_trylock(&rwp->read_access_completion_mutex)) != 0)
355     {
356         pthread_mutex_unlock(&rwp->write_access_mutex);
357         return rc;
358     }
359
360     if (rwp->readers > 0)
361         rc = EBUSY;
362
363     pthread_mutex_unlock(&rwp->read_access_completion_mutex);
364
365     if (rc)
366         pthread_mutex_unlock(&rwp->write_access_mutex);
367
368     return rc;
369 }
370
371 int pthread_rwlock_unlock(pthread_rwlock_t *rwp)
372 {
373     int rc = 0;
374
375     if (rwp == NULL)
376         return EINVAL;
377
378     rc = pthread_mutex_trylock(&rwp->write_access_mutex);
379     if (rc != EDEADLK)
380     {
381         /* unlock a read lock */
382         if (rc == 0)
383             pthread_mutex_unlock(&rwp->write_access_mutex);
384
385         if ((rc = pthread_mutex_lock(&rwp->read_access_completion_mutex)) != 0)
386         {
387             pthread_mutex_unlock(&rwp->write_access_mutex);
388             return rc;
389         }
390
391         if (rwp->readers <= 0)
392         {
393             rc = EINVAL;
394         }
395         else
396         {
397             if (--rwp->readers == 0)
398                 pthread_cond_broadcast(&rwp->read_access_completion_wait);
399         }
400
401         pthread_mutex_unlock(&rwp->read_access_completion_mutex);
402     }
403     else
404     {
405         /* unlock a write lock */
406         rc = pthread_mutex_unlock(&rwp->write_access_mutex);
407     }
408
409     return rc;
410 }
411
412
413 /*
414  * keys is used to keep track of which keys are currently
415  * in use by the threads library.  pthread_tsd_mutex is used
416  * to protect keys.
417  *
418  * The bookkeeping for keys in use and destructor function/key is
419  * at the library level.  Each individual thread only keeps its
420  * per key data value.  This implies that the keys array and the
421  * tsd array in the pthread_t structure need to always be exactly
422  * the same size since the same index is used for both arrays.
423  */
424
425 typedef struct {
426     int inuse;
427     void (*destructor)(void *);
428 } pthread_tsd_table_t;
429
430 static pthread_tsd_table_t keys[PTHREAD_KEYS_MAX];
431 static pthread_mutex_t pthread_tsd_mutex;
432 static pthread_once_t pthread_tsd_once = PTHREAD_ONCE_INIT;
433
434 /*
435  * In order to support p_self() and p_join() under NT,
436  * we have to keep our own list of active threads and provide a mapping
437  * function that maps the NT thread id to our internal structure.
438  * The main reason that this is necessary is that GetCurrentThread
439  * returns a special constant not an actual handle to the thread.
440  * This makes it impossible to write a p_self() function that works
441  * with only the native NT functions.
442  */
443
444 static struct rx_queue active_Q;
445 static struct rx_queue cache_Q;
446
447 static pthread_mutex_t active_Q_mutex;
448 static pthread_mutex_t cache_Q_mutex;
449
450 static pthread_once_t pthread_cache_once = PTHREAD_ONCE_INIT;
451 static int pthread_cache_done;
452
453 typedef struct thread {
454     struct rx_queue thread_queue;
455     void *rc;
456     int running;
457     pthread_cond_t wait_terminate;
458     int waiter_count;
459     int is_joinable;
460     int has_been_joined;
461     HANDLE t_handle;
462     DWORD NT_id;
463     int native_thread;
464     char **tsd;
465 } thread_t, *thread_p;
466
467 static void create_once(void) {
468     queue_Init(&active_Q);
469     queue_Init(&cache_Q);
470     pthread_mutex_init(&active_Q_mutex, (const pthread_mutexattr_t*)0);
471     pthread_mutex_init(&cache_Q_mutex, (const pthread_mutexattr_t*)0);
472     pthread_cache_done = 1;
473 }
474
475 static void cleanup_pthread_cache(void) {
476     thread_p cur = NULL, next = NULL;
477
478     if (pthread_cache_done) {
479         for(queue_Scan(&active_Q, cur, next, thread)) {
480             queue_Remove(cur);
481         }
482         for(queue_Scan(&cache_Q, cur, next, thread)) {
483             queue_Remove(cur);
484         }
485
486         pthread_mutex_destroy(&active_Q_mutex);
487         pthread_mutex_destroy(&cache_Q_mutex);
488
489         pthread_cache_done = 0;
490     }
491 }
492
493 static void put_thread(thread_p old) {
494
495     CloseHandle(old->t_handle);
496     pthread_mutex_lock(&cache_Q_mutex);
497     queue_Prepend(&cache_Q, old);
498     pthread_mutex_unlock(&cache_Q_mutex);
499 }
500
501 static thread_p get_thread() {
502     thread_p new = NULL;
503
504     pthread_mutex_lock(&cache_Q_mutex);
505
506     if (queue_IsEmpty(&cache_Q)) {
507         new = (thread_p) malloc(sizeof(thread_t));
508         if (new != NULL) {
509             /*
510              * One time initialization - we assume threads put back have
511              * unlocked mutexes and condition variables with no waiters
512              *
513              * These functions cannot fail currently.
514              */
515             pthread_cond_init(&new->wait_terminate,(const pthread_condattr_t *)0);
516         }
517     } else {
518         new = queue_First(&cache_Q, thread);
519         queue_Remove(new);
520     }
521
522     pthread_mutex_unlock(&cache_Q_mutex);
523
524     /*
525      * Initialization done every time we hand out a thread_t
526      */
527
528     if (new != NULL) {
529         new->rc = NULL;
530         new->running = 1;
531         new->waiter_count = 0;
532         new->has_been_joined = 0;
533     }
534     return new;
535
536 }
537
538 /*
539  * The thread start function signature is different on NT than the pthread
540  * spec so we create a tiny stub to map from one signature to the next.
541  * This assumes that a void * can be stored within a DWORD.
542  */
543
544 typedef struct {
545     void *(*func)(void *);
546     void *arg;
547     char *tsd[PTHREAD_KEYS_MAX];
548     thread_p me;
549 } pthread_create_t;
550
551 static DWORD tsd_index = 0xffffffff;
552 static DWORD tsd_pthread_index = 0xffffffff;
553 static pthread_once_t global_tsd_once = PTHREAD_ONCE_INIT;
554 static int tsd_done;
555
556 static void tsd_once(void) {
557     while(tsd_index == 0xffffffff) {
558         tsd_index = TlsAlloc();
559     }
560     while(tsd_pthread_index == 0xffffffff) {
561         tsd_pthread_index = TlsAlloc();
562     }
563     tsd_done = 1;
564 }
565
566 static void tsd_free_all(char *tsd[PTHREAD_KEYS_MAX]) {
567     int call_more_destructors = 0;
568     do {
569         int i;
570         void *value;
571         void (*destructor)(void *);
572         call_more_destructors = 0;
573         for(i=0;i<PTHREAD_KEYS_MAX;i++) {
574             if (tsd[i] != NULL) {
575                 destructor = keys[i].destructor;
576                 value = (void *)tsd[i];
577                 tsd[i] = NULL;
578                 if (destructor != NULL) {
579                     (destructor)(value);
580                     /*
581                      * A side-effect of calling a destructor function is that
582                      * more thread specific may be created for this thread.
583                      * If we call a destructor, we must recycle through the
584                      * entire list again and run any new destructors.
585                      */
586                     call_more_destructors = 1;
587                 }
588             }
589         }
590     } while(call_more_destructors);
591 }
592
593 static void cleanup_global_tsd(void)
594 {
595     thread_p cur = NULL, next = NULL;
596
597     if (tsd_done) {
598         for(queue_Scan(&active_Q, cur, next, thread)) {
599             tsd_free_all(cur->tsd);
600         }
601
602         TlsFree(tsd_pthread_index);
603         tsd_pthread_index = 0xFFFFFFFF;
604         TlsFree(tsd_index);
605         tsd_index = 0xFFFFFFFF;
606         tsd_done = 0;
607     }
608 }
609
610 static DWORD WINAPI afs_pthread_create_stub(LPVOID param) {
611     pthread_create_t *t = (pthread_create_t *) param;
612     void *rc;
613
614     /*
615      * Initialize thread specific storage structures.
616      */
617
618     memset(t->tsd, 0, (sizeof(char *) * PTHREAD_KEYS_MAX));
619     (tsd_done || pthread_once(&global_tsd_once, tsd_once));
620     TlsSetValue(tsd_index, (LPVOID) (t->tsd));
621     TlsSetValue(tsd_pthread_index, (LPVOID) (t->me));
622
623     /*
624      * Call the function the user passed to pthread_create and catch the
625      * pthread exit exception if it is raised.
626      */
627
628     __try {
629         rc = (*(t->func))(t->arg);
630     } __except(GetExceptionCode() == PTHREAD_EXIT_EXCEPTION) {
631         rc = t->me->rc; /* rc is set at pthread_exit */
632     }
633
634     /*
635      * Cycle through the thread specific data for this thread and
636      * call the destructor function for each non-NULL datum
637      */
638
639     tsd_free_all (t->tsd);
640     t->me->tsd = NULL;
641
642     /*
643      * If we are joinable, signal any waiters.
644      */
645
646     pthread_mutex_lock(&active_Q_mutex);
647     if (t->me->is_joinable) {
648         t->me->running = 0;
649         t->me->rc = rc;
650         if (t->me->waiter_count) {
651             pthread_cond_broadcast(&t->me->wait_terminate);
652         }
653     } else {
654         queue_Remove(t->me);
655         put_thread(t->me);
656     }
657     pthread_mutex_unlock(&active_Q_mutex);
658
659     free(t);
660     return 0;
661 }
662
663 /*
664  * If a pthread function is called on a thread which was not created by
665  * pthread_create(), that thread will have an entry added to the active_Q
666  * by pthread_self(). When the thread terminates, we need to know
667  * about it, so that we can perform cleanup. A dedicated thread is therefore
668  * maintained, which watches for any thread marked "native_thread==1"
669  * in the active_Q to terminate. The thread spends most of its time sleeping:
670  * it can be signalled by a dedicated event in order to alert it to the
671  * presense of a new thread to watch, or will wake up automatically when
672  * a native thread terminates.
673  */
674
675 static DWORD terminate_thread_id = 0;
676 static HANDLE terminate_thread_handle = INVALID_HANDLE_VALUE;
677 static HANDLE terminate_thread_wakeup_event = INVALID_HANDLE_VALUE;
678 static HANDLE *terminate_thread_wakeup_list = NULL;
679 static size_t terminate_thread_wakeup_list_size = 0;
680
681 static DWORD WINAPI terminate_thread_routine(LPVOID param) {
682     thread_p cur, next;
683     DWORD native_thread_count;
684     int should_terminate;
685     int terminate_thread_wakeup_list_index;
686
687     for (;;) {
688         /*
689          * Grab the active_Q_mutex, and while we hold it, scan the active_Q
690          * to see how many native threads we need to watch. If we don't need
691          * to watch any, we can stop this watcher thread entirely (or not);
692          * if we do need to watch some, fill the terminate_thread_wakeup_list
693          * array and go to sleep.
694          */
695         cur = NULL;
696         next = NULL;
697         native_thread_count = 0;
698         should_terminate = FALSE;
699         pthread_mutex_lock(&active_Q_mutex);
700
701         for(queue_Scan(&active_Q, cur, next, thread)) {
702             if (cur->native_thread)
703                 ++native_thread_count;
704         }
705
706         /*
707          * At this point we could decide to terminate this watcher thread
708          * whenever there are no longer any native threads to watch--however,
709          * since thread creation is a time-consuming thing, and since this
710          * thread spends all its time sleeping anyway, there's no real
711          * compelling reason to do so. Thus, the following statement is
712          * commented out:
713          *
714          * if (!native_thread_count) {
715          *    should_terminate = TRUE;
716          * }
717          *
718          * Restore the snippet above to cause this watcher thread to only
719          * live whenever there are native threads to watch.
720          *
721          */
722
723         /*
724          * Make sure that our wakeup_list array is large enough to contain
725          * the handles of all the native threads /and/ to contain an
726          * entry for our wakeup_event (in case another native thread comes
727          * along).
728          */
729         if (terminate_thread_wakeup_list_size < (1+native_thread_count)) {
730             if (terminate_thread_wakeup_list)
731                 free (terminate_thread_wakeup_list);
732             terminate_thread_wakeup_list = (HANDLE*)malloc (sizeof(HANDLE) *
733                                 (1+native_thread_count));
734             if (terminate_thread_wakeup_list == NULL) {
735                 should_terminate = TRUE;
736             } else {
737                 terminate_thread_wakeup_list_size = 1+native_thread_count;
738             }
739         }
740
741         if (should_terminate) {
742             /*
743              * Here, we've decided to terminate this watcher thread.
744              * Free our wakeup event and wakeup list, then release the
745              * active_Q_mutex and break this loop.
746              */
747             if (terminate_thread_wakeup_list)
748                 free (terminate_thread_wakeup_list);
749             CloseHandle (terminate_thread_wakeup_event);
750             terminate_thread_id = 0;
751             terminate_thread_handle = INVALID_HANDLE_VALUE;
752             terminate_thread_wakeup_event = INVALID_HANDLE_VALUE;
753             terminate_thread_wakeup_list = NULL;
754             terminate_thread_wakeup_list_size = 0;
755             pthread_mutex_unlock(&active_Q_mutex);
756             break;
757         } else {
758             /*
759              * Here, we've decided to wait for native threads et al.
760              * Fill out the wakeup_list.
761              */
762             memset(terminate_thread_wakeup_list, 0x00, (sizeof(HANDLE) *
763                                 (1+native_thread_count)));
764
765             terminate_thread_wakeup_list[0] = terminate_thread_wakeup_event;
766             terminate_thread_wakeup_list_index = 1;
767
768             cur = NULL;
769             next = NULL;
770             for(queue_Scan(&active_Q, cur, next, thread)) {
771                 if (cur->native_thread) {
772                     terminate_thread_wakeup_list[terminate_thread_wakeup_list_index]
773                         = cur->t_handle;
774                     ++terminate_thread_wakeup_list_index;
775                 }
776             }
777
778             ResetEvent (terminate_thread_wakeup_event);
779         }
780
781         pthread_mutex_unlock(&active_Q_mutex);
782
783         /*
784          * Time to sleep. We'll wake up if either of the following happen:
785          * 1) Someone sets the terminate_thread_wakeup_event (this will
786          *    happen if another native thread gets added to the active_Q)
787          * 2) One or more of the native threads terminate
788          */
789         terminate_thread_wakeup_list_index = WaitForMultipleObjects(
790                                         1+native_thread_count,
791                                         terminate_thread_wakeup_list,
792                                         FALSE,
793                                         INFINITE);
794
795         /*
796          * If we awoke from sleep because an event other than
797          * terminate_thread_wakeup_event was triggered, it means the
798          * specified thread has terminated. (If more than one thread
799          * terminated, we'll handle this first one and loop around--
800          * the event's handle will still be triggered, so we just won't
801          * block at all when we sleep next time around.)
802          */
803         if (terminate_thread_wakeup_list_index > 0) {
804             pthread_mutex_lock(&active_Q_mutex);
805
806             cur = NULL;
807             next = NULL;
808             for(queue_Scan(&active_Q, cur, next, thread)) {
809                 if (cur->t_handle == terminate_thread_wakeup_list[ terminate_thread_wakeup_list_index ])
810                     break;
811             }
812
813             if(cur != NULL) {
814                 /*
815                  * Cycle through the thread specific data for the specified
816                  * thread and call the destructor function for each non-NULL
817                  * datum. Then remove the thread_t from active_Q and put it
818                  * back on cache_Q for possible later re-use.
819                  */
820                 if(cur->tsd != NULL) {
821                     tsd_free_all(cur->tsd);
822                     free(cur->tsd);
823                     cur->tsd = NULL;
824                 }
825                 queue_Remove(cur);
826                 put_thread(cur);
827             }
828
829             pthread_mutex_unlock(&active_Q_mutex);
830         }
831     }
832     return 0;
833 }
834
835
836 static void pthread_sync_terminate_thread(void) {
837     (pthread_cache_done || pthread_once(&pthread_cache_once, create_once));
838
839     if (terminate_thread_handle == INVALID_HANDLE_VALUE) {
840         CHAR eventName[MAX_PATH];
841         static eventCount = 0;
842         sprintf(eventName, "terminate_thread_wakeup_event %d::%d", _getpid(), eventCount++);
843         terminate_thread_wakeup_event = CreateEvent((LPSECURITY_ATTRIBUTES) 0,
844                                                      TRUE, FALSE, (LPCTSTR) eventName);
845         terminate_thread_handle = CreateThread((LPSECURITY_ATTRIBUTES) 0, 0,
846                                                 terminate_thread_routine, (LPVOID) 0, 0,
847                                                 &terminate_thread_id);
848     } else {
849         SetEvent (terminate_thread_wakeup_event);
850     }
851 }
852
853
854 /*
855  * Only support the detached attribute specifier for pthread_create.
856  * Under NT, thread stacks grow automatically as needed.
857  */
858
859 int pthread_create(pthread_t *tid, const pthread_attr_t *attr, void *(*func)(void *), void *arg) {
860     int rc = 0;
861     pthread_create_t *t = NULL;
862
863     (pthread_cache_done || pthread_once(&pthread_cache_once, create_once));
864
865     if ((tid != NULL) && (func != NULL)) {
866         if ((t = (pthread_create_t *) malloc(sizeof(pthread_create_t))) &&
867             (t->me = get_thread()) ) {
868             t->func = func;
869             t->arg = arg;
870             *tid = (pthread_t) t->me;
871             if (attr != NULL) {
872                 t->me->is_joinable = attr->is_joinable;
873             } else {
874                 t->me->is_joinable = PTHREAD_CREATE_JOINABLE;
875             }
876             t->me->native_thread = 0;
877             t->me->tsd = t->tsd;
878             /*
879              * At the point (before we actually create the thread)
880              * we need to add our entry to the active queue.  This ensures
881              * us that other threads who may run after this thread returns
882              * will find an entry for the create thread regardless of
883              * whether the newly created thread has run or not.
884              * In the event the thread create fails, we will have temporarily
885              * added an entry to the list that was never valid, but we
886              * (i.e. the thread that is calling thread_create) are the
887              * only one who could possibly know about the bogus entry
888              * since we hold the active_Q_mutex.
889              */
890             pthread_mutex_lock(&active_Q_mutex);
891             queue_Prepend(&active_Q, t->me);
892             t->me->t_handle = CreateThread((LPSECURITY_ATTRIBUTES) 0, 0,
893                                 afs_pthread_create_stub, (LPVOID) t, 0,
894                                 &t->me->NT_id);
895             if (t->me->t_handle == 0) {
896                 /*
897                  * we only free t if the thread wasn't created, otherwise
898                  * it's free'd by the new thread.
899                  */
900                 queue_Remove(t->me);
901                 put_thread(t->me);
902                 free(t);
903                 rc = EAGAIN;
904             }
905             pthread_mutex_unlock(&active_Q_mutex);
906         } else {
907             if (t != NULL) {
908                 free(t);
909             }
910             rc = ENOMEM;
911         }
912     } else {
913         rc = EINVAL;
914     }
915     return rc;
916 }
917
918 int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr) {
919     int rc = 0;
920
921     /*
922      * Only support default attribute -> must pass a NULL pointer for
923      * attr parameter.
924      */
925     if ((attr == NULL) && (cond != NULL)) {
926         memset(cond, 0, sizeof(*cond));
927         InitializeCriticalSection(&cond->cs);
928         queue_Init(&cond->waiting_threads);
929     } else {
930         rc = EINVAL;
931     }
932
933     return rc;
934 }
935
936 /*
937  * In order to optimize the performance of condition variables,
938  * we maintain a pool of cond_waiter_t's that have been dynamically
939  * allocated.  There is no attempt made to garbage collect these -
940  * once they have been created, they stay in the cache for the life
941  * of the process.
942  */
943
944 static struct rx_queue waiter_cache;
945 static CRITICAL_SECTION waiter_cache_cs;
946 static int waiter_cache_init;
947 static pthread_once_t waiter_cache_once = PTHREAD_ONCE_INIT;
948
949 static void init_waiter_cache(void) {
950     if (waiter_cache_init)
951         return;
952
953     memset(&waiter_cache_cs, 0, sizeof(waiter_cache_cs));
954     InitializeCriticalSection(&waiter_cache_cs);
955     queue_Init(&waiter_cache);
956     waiter_cache_init = 1;
957 }
958
959 static void cleanup_waiter_cache(void)
960 {
961     cond_waiters_t * cur = NULL, * next = NULL;
962
963     if (waiter_cache_init) {
964         for(queue_Scan(&waiter_cache, cur, next, cond_waiter)) {
965             queue_Remove(cur);
966
967             CloseHandle(cur->event);
968             free(cur);
969         }
970
971         DeleteCriticalSection(&waiter_cache_cs);
972         waiter_cache_init = 0;
973     }
974 }
975
976 static cond_waiters_t *get_waiter() {
977     cond_waiters_t *new = NULL;
978
979     (waiter_cache_init || pthread_once(&waiter_cache_once, init_waiter_cache));
980
981     EnterCriticalSection(&waiter_cache_cs);
982
983     if (queue_IsEmpty(&waiter_cache)) {
984         new = (cond_waiters_t *) malloc(sizeof(cond_waiters_t));
985         if (new != NULL) {
986         CHAR eventName[MAX_PATH];
987         static eventCount = 0;
988         sprintf(eventName, "cond_waiters_t %d::%d", _getpid(), eventCount++);
989         new->event = CreateEvent((LPSECURITY_ATTRIBUTES) 0, FALSE,
990                                   FALSE, (LPCTSTR) eventName);
991             if (new->event == NULL) {
992                 free(new);
993                 new = NULL;
994             }
995         }
996     } else {
997         new = queue_First(&waiter_cache, cond_waiter);
998         queue_Remove(new);
999     }
1000
1001     LeaveCriticalSection(&waiter_cache_cs);
1002     return new;
1003
1004 }
1005
1006 static void put_waiter(cond_waiters_t *old) {
1007
1008     (waiter_cache_init || pthread_once(&waiter_cache_once, init_waiter_cache));
1009
1010     EnterCriticalSection(&waiter_cache_cs);
1011     queue_Prepend(&waiter_cache, old);
1012     LeaveCriticalSection(&waiter_cache_cs);
1013 }
1014
1015 static int cond_wait_internal(pthread_cond_t *cond, pthread_mutex_t *mutex, const DWORD time) {
1016     int rc=0;
1017     cond_waiters_t *my_entry = get_waiter();
1018     cond_waiters_t *cur, *next;
1019     int hasnt_been_signalled=0;
1020
1021     if ((cond != NULL) && (mutex != NULL) && (my_entry != NULL)) {
1022         EnterCriticalSection(&cond->cs);
1023         queue_Append(&cond->waiting_threads, my_entry);
1024         LeaveCriticalSection(&cond->cs);
1025
1026         if (pthread_mutex_unlock(mutex) == 0) {
1027             switch(WaitForSingleObject(my_entry->event, time)) {
1028             case WAIT_FAILED:
1029                 rc = -1;
1030                 break;
1031             case WAIT_TIMEOUT:
1032                 rc = ETIMEDOUT;
1033                 /*
1034                  * This is a royal pain.  We've timed out waiting
1035                  * for the signal, but between the time out and here
1036                  * it is possible that we were actually signalled by
1037                  * another thread.  So we grab the condition lock
1038                  * and scan the waiting thread queue to see if we are
1039                  * still there.  If we are, we just remove ourselves.
1040                  *
1041                  * If we are no longer listed in the waiter queue,
1042                  * it means that we were signalled after the time
1043                  * out occurred and so we have to do another wait
1044                  * WHICH HAS TO SUCCEED!  In this case, we reset
1045                  * rc to indicate that we were signalled.
1046                  *
1047                  * We have to wait or otherwise, the event
1048                  * would be cached in the signalled state, which
1049                  * is wrong.  It might be more efficient to just
1050                  * close and reopen the event.
1051                  */
1052                 EnterCriticalSection(&cond->cs);
1053                 for(queue_Scan(&cond->waiting_threads, cur,
1054                                 next, cond_waiter)) {
1055                     if (cur == my_entry) {
1056                         hasnt_been_signalled = 1;
1057                         break;
1058                     }
1059                 }
1060                 if (hasnt_been_signalled) {
1061                     queue_Remove(cur);
1062                 } else {
1063                     rc = 0;
1064                     if (!ResetEvent(my_entry->event)) {
1065                         rc = -6;
1066                     }
1067                 }
1068                 LeaveCriticalSection(&cond->cs);
1069                 break;
1070             case WAIT_ABANDONED:
1071                 rc = -2;
1072                 break;
1073             case WAIT_OBJECT_0:
1074                 rc = 0;
1075                 break;
1076             default:
1077                 rc = -4;
1078                 break;
1079             }
1080             if (pthread_mutex_lock(mutex) != 0) {
1081                 rc = -3;
1082             }
1083         } else {
1084             rc = EINVAL;
1085         }
1086     } else {
1087         rc = EINVAL;
1088     }
1089
1090     if (my_entry != NULL) {
1091         put_waiter(my_entry);
1092     }
1093
1094     return rc;
1095 }
1096
1097 int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) {
1098     int rc = 0;
1099
1100     rc = cond_wait_internal(cond, mutex, INFINITE);
1101     return rc;
1102 }
1103
1104 int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime) {
1105     int rc = 0;
1106     struct _timeb now, then;
1107     afs_uint32 n_milli, t_milli;
1108
1109     if (abstime->tv_nsec < 1000000000) {
1110
1111         /*
1112          * pthread timedwait uses an absolute time, NT uses relative so
1113          * we convert here.  The millitm field in the timeb struct is
1114          * unsigned, but we need to do subtraction preserving the sign,
1115          * so we copy the fields into temporary variables.
1116          *
1117          * WARNING:
1118          * In NT 4.0 SP3, WaitForSingleObject can occassionally timeout
1119          * earlier than requested.  Therefore, our pthread_cond_timedwait
1120          * can also return early.
1121          */
1122
1123         _ftime(&now);
1124         n_milli = now.millitm;
1125         then.time = abstime->tv_sec;
1126         t_milli = abstime->tv_nsec/1000000;
1127
1128         if((then.time > now.time ||
1129            (then.time == now.time && t_milli > n_milli))) {
1130             if((t_milli -= n_milli) < 0) {
1131                 t_milli += 1000;
1132                 then.time--;
1133             }
1134             then.time -= now.time;
1135
1136             if ((then.time + (clock() / CLOCKS_PER_SEC)) <= 50000000) {
1137                 /*
1138                  * Under NT, we can only wait for milliseconds, so we
1139                  * round up the wait time here.
1140                  */
1141                 rc = cond_wait_internal(cond, mutex,
1142                                  (DWORD)((then.time * 1000) + (t_milli)));
1143             } else {
1144                 rc = EINVAL;
1145             }
1146         } else {
1147             rc = ETIME;
1148         }
1149     } else {
1150         rc = EINVAL;
1151     }
1152
1153     return rc;
1154 }
1155
1156 int pthread_cond_signal(pthread_cond_t *cond) {
1157     int rc = 0;
1158     cond_waiters_t *release_thread;
1159
1160     if (cond != NULL) {
1161         EnterCriticalSection(&cond->cs);
1162
1163         /*
1164          * remove the first waiting thread from the queue
1165          * and resume his execution
1166          */
1167         if (queue_IsNotEmpty(&cond->waiting_threads)) {
1168             release_thread = queue_First(&cond->waiting_threads,
1169                                          cond_waiter);
1170             queue_Remove(release_thread);
1171             if (!SetEvent(release_thread->event)) {
1172                 rc = -1;
1173             }
1174         }
1175
1176         LeaveCriticalSection(&cond->cs);
1177     } else {
1178         rc = EINVAL;
1179     }
1180
1181     return rc;
1182 }
1183
1184 int pthread_cond_broadcast(pthread_cond_t *cond) {
1185     int rc = 0;
1186     cond_waiters_t *release_thread, *next_thread;
1187
1188     if(cond != NULL) {
1189         EnterCriticalSection(&cond->cs);
1190
1191         /*
1192          * Empty the waiting_threads queue.
1193          */
1194         if (queue_IsNotEmpty(&cond->waiting_threads)) {
1195             for(queue_Scan(&cond->waiting_threads, release_thread,
1196                            next_thread, cond_waiter)) {
1197                 queue_Remove(release_thread);
1198                 if (!SetEvent(release_thread->event)) {
1199                     rc = -1;
1200                 }
1201             }
1202         }
1203
1204         LeaveCriticalSection(&cond->cs);
1205     } else {
1206         rc = EINVAL;
1207     }
1208
1209     return rc;
1210 }
1211
1212 int pthread_cond_destroy(pthread_cond_t *cond) {
1213     int rc = 0;
1214
1215     if (cond != NULL) {
1216         DeleteCriticalSection(&cond->cs);
1217     } else {
1218         rc = EINVAL;
1219     }
1220
1221     /*
1222      * A previous version of this file had code to check the waiter
1223      * queue and empty it here.  This has been removed in the hopes
1224      * that it will aid in debugging.
1225      */
1226
1227     return rc;
1228 }
1229
1230 int pthread_join(pthread_t target_thread, void **status) {
1231     int rc = 0;
1232     thread_p me, target;
1233     thread_p cur, next;
1234
1235     target = (thread_p) target_thread;
1236     me = (thread_p) pthread_self();
1237
1238     if (me != target) {
1239         /*
1240          * Check to see that the target thread is joinable and hasn't
1241          * already been joined.
1242          */
1243
1244         pthread_mutex_lock(&active_Q_mutex);
1245
1246         for(queue_Scan(&active_Q, cur, next, thread)) {
1247             if (target == cur) break;
1248         }
1249
1250         if (target == cur) {
1251             if ((!target->is_joinable) || (target->has_been_joined)) {
1252                 rc = ESRCH;
1253             }
1254         } else {
1255             rc = ESRCH;
1256         }
1257
1258         if (rc) {
1259             pthread_mutex_unlock(&active_Q_mutex);
1260             return rc;
1261         }
1262
1263         target->waiter_count++;
1264         while(target->running) {
1265             pthread_cond_wait(&target->wait_terminate, &active_Q_mutex);
1266         }
1267
1268         /*
1269          * Only one waiter gets the status and is allowed to join, all the
1270          * others get an error.
1271          */
1272
1273         if (target->has_been_joined) {
1274             rc = ESRCH;
1275         } else {
1276             target->has_been_joined = 1;
1277             if (status) {
1278                 *status = target->rc;
1279             }
1280         }
1281
1282         /*
1283          * If we're the last waiter it is our responsibility to remove
1284          * this entry from the terminated list and put it back in the
1285          * cache.
1286          */
1287
1288         target->waiter_count--;
1289         if (target->waiter_count == 0) {
1290             queue_Remove(target);
1291             pthread_mutex_unlock(&active_Q_mutex);
1292             put_thread(target);
1293         } else {
1294             pthread_mutex_unlock(&active_Q_mutex);
1295         }
1296     } else {
1297         rc = EDEADLK;
1298     }
1299
1300     return rc;
1301 }
1302
1303 /*
1304  * Note that we can't return an error from pthread_getspecific so
1305  * we return a NULL pointer instead.
1306  */
1307
1308 void *pthread_getspecific(pthread_key_t key) {
1309     void *rc = NULL;
1310     char **tsd = TlsGetValue(tsd_index);
1311
1312     if (tsd == NULL)
1313         return NULL;
1314
1315     if ((key > -1) && (key < PTHREAD_KEYS_MAX )) {
1316         rc = (void *) *(tsd + key);
1317     }
1318
1319     return rc;
1320 }
1321
1322 static int p_tsd_done;
1323
1324 static void pthread_tsd_init(void) {
1325     pthread_mutex_init(&pthread_tsd_mutex, (const pthread_mutexattr_t*)0);
1326     p_tsd_done = 1;
1327 }
1328
1329 int pthread_key_create(pthread_key_t *keyp, void (*destructor)(void *value)) {
1330     int rc = 0;
1331     int i;
1332
1333     if (p_tsd_done || (!pthread_once(&pthread_tsd_once, pthread_tsd_init))) {
1334         if (!pthread_mutex_lock(&pthread_tsd_mutex)) {
1335             for(i=0;i<PTHREAD_KEYS_MAX;i++) {
1336                 if (!keys[i].inuse) break;
1337             }
1338
1339             if (!keys[i].inuse) {
1340                 keys[i].inuse = 1;
1341                 keys[i].destructor = destructor;
1342                 *keyp = i;
1343             } else {
1344                 rc = EAGAIN;
1345             }
1346             pthread_mutex_unlock(&pthread_tsd_mutex);
1347         } else {
1348             rc = -1;
1349         }
1350     } else {
1351         rc = -2;
1352     }
1353
1354     return rc;
1355 }
1356
1357 int pthread_key_delete(pthread_key_t key) {
1358     int rc = 0;
1359
1360     if (p_tsd_done || (!pthread_once(&pthread_tsd_once, pthread_tsd_init))) {
1361         if ((key > -1) && (key < PTHREAD_KEYS_MAX )) {
1362             if (!pthread_mutex_lock(&pthread_tsd_mutex)) {
1363                 keys[key].inuse = 0;
1364                 keys[key].destructor = NULL;
1365                 pthread_mutex_unlock(&pthread_tsd_mutex);
1366             } else {
1367                 rc = -1;
1368             }
1369         } else {
1370             rc = EINVAL;
1371         }
1372     } else {
1373         rc = -2;
1374     }
1375
1376     return rc;
1377 }
1378
1379 int pthread_setspecific(pthread_key_t key, const void *value) {
1380     int rc = 0;
1381     char **tsd;
1382
1383     /* make sure all thread-local storage has been allocated */
1384     pthread_self();
1385
1386     if (p_tsd_done || (!pthread_once(&pthread_tsd_once, pthread_tsd_init))) {
1387         if ((key > -1) && (key < PTHREAD_KEYS_MAX )) {
1388             if (!pthread_mutex_lock(&pthread_tsd_mutex)) {
1389                 if (keys[key].inuse) {
1390                     tsd = TlsGetValue(tsd_index);
1391                     *(tsd + key) = (char *) value;
1392                 } else {
1393                     rc = EINVAL;
1394                 }
1395                 pthread_mutex_unlock(&pthread_tsd_mutex);
1396             } else {
1397                 rc = -1;
1398             }
1399         } else {
1400             rc = EINVAL;
1401         }
1402     } else {
1403       rc = -2;
1404     }
1405
1406     return rc;
1407 }
1408
1409 pthread_t pthread_self(void) {
1410     thread_p cur;
1411     DWORD my_id = GetCurrentThreadId();
1412
1413     (pthread_cache_done || pthread_once(&pthread_cache_once, create_once));
1414     (tsd_done || pthread_once(&global_tsd_once, tsd_once));
1415
1416     pthread_mutex_lock(&active_Q_mutex);
1417
1418     cur = TlsGetValue (tsd_pthread_index);
1419
1420     if(!cur) {
1421         /*
1422          * This thread's ID was not found in our list of pthread-API client
1423          * threads (e.g., those threads created via pthread_create). Create
1424          * an entry for it.
1425          */
1426         if ((cur = get_thread()) != NULL) {
1427             cur->is_joinable = 0;
1428             cur->NT_id = my_id;
1429             cur->native_thread = 1;
1430             DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
1431              GetCurrentProcess(), &cur->t_handle, 0,
1432              TRUE, DUPLICATE_SAME_ACCESS);
1433
1434             /*
1435              * We'll also need a place to store key data for this thread
1436              */
1437             if ((cur->tsd = malloc(sizeof(char*) * PTHREAD_KEYS_MAX)) != NULL) {
1438                 memset(cur->tsd, 0, (sizeof(char*) * PTHREAD_KEYS_MAX));
1439             }
1440             TlsSetValue(tsd_index, (LPVOID)cur->tsd);
1441             TlsSetValue(tsd_pthread_index, (LPVOID)cur);
1442
1443             /*
1444              * The thread_t structure is complete; add it to the active_Q
1445              */
1446             queue_Prepend(&active_Q, cur);
1447
1448             /*
1449              * We were able to successfully insert a new entry into the
1450              * active_Q; however, when this thread terminates, we will need
1451              * to know about it. The pthread_sync_terminate_thread() routine
1452              * will make sure there is a dedicated thread waiting for any
1453              * native-thread entries in the active_Q to terminate.
1454              */
1455             pthread_sync_terminate_thread();
1456         }
1457     }
1458
1459     pthread_mutex_unlock(&active_Q_mutex);
1460
1461     return (void *) cur;
1462 }
1463
1464 int pthread_equal(pthread_t t1, pthread_t t2) {
1465     return (t1 == t2);
1466 }
1467
1468 int pthread_attr_destroy(pthread_attr_t *attr) {
1469     int rc = 0;
1470
1471     return rc;
1472 }
1473
1474 int pthread_attr_init(pthread_attr_t *attr) {
1475     int rc = 0;
1476
1477     if (attr != NULL) {
1478         attr->is_joinable = PTHREAD_CREATE_JOINABLE;
1479     } else {
1480         rc = EINVAL;
1481     }
1482
1483     return rc;
1484 }
1485
1486 int pthread_attr_getdetachstate(pthread_attr_t *attr, int *detachstate) {
1487     int rc = 0;
1488
1489     if ((attr != NULL) && (detachstate != NULL)) {
1490             *detachstate = attr->is_joinable;
1491     } else {
1492         rc = EINVAL;
1493     }
1494     return rc;
1495 }
1496
1497 int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate) {
1498     int rc = 0;
1499
1500     if ((attr != NULL) && ((detachstate == PTHREAD_CREATE_JOINABLE) ||
1501         (detachstate == PTHREAD_CREATE_DETACHED))) {
1502         attr->is_joinable = detachstate;
1503     } else {
1504         rc = EINVAL;
1505     }
1506     return rc;
1507 }
1508
1509 void pthread_exit(void *status) {
1510     thread_p me = (thread_p) pthread_self();
1511
1512     /*
1513      * Support pthread_exit for thread's created by calling pthread_create
1514      * only.  Do this by using an exception that will transfer control
1515      * back to afs_pthread_create_stub.  Store away our status before
1516      * returning.
1517      *
1518      * If this turns out to be a native thread, the exception will be
1519      * unhandled and the process will terminate.
1520      */
1521
1522     me->rc = status;
1523     RaiseException(PTHREAD_EXIT_EXCEPTION, 0, 0, NULL);
1524
1525 }
1526
1527 /*
1528  * DllMain() -- Entry-point function called by the DllMainCRTStartup()
1529  *     function in the MSVC runtime DLL (msvcrt.dll).
1530  *
1531  *     Note: the system serializes calls to this function.
1532  */
1533 BOOL WINAPI
1534 DllMain(HINSTANCE dllInstHandle,/* instance handle for this DLL module */
1535         DWORD reason,           /* reason function is being called */
1536         LPVOID reserved)
1537 {                               /* reserved for future use */
1538     switch (reason) {
1539     case DLL_PROCESS_ATTACH:
1540         /* library is being attached to a process */
1541         /* disable thread attach/detach notifications */
1542         (void)DisableThreadLibraryCalls(dllInstHandle);
1543
1544         pthread_once(&pthread_cache_once, create_once);
1545         pthread_once(&global_tsd_once, tsd_once);
1546         pthread_once(&waiter_cache_once, init_waiter_cache);
1547         return TRUE;
1548
1549     case DLL_PROCESS_DETACH:
1550         cleanup_waiter_cache();
1551         cleanup_global_tsd();
1552         cleanup_pthread_cache();
1553         return TRUE;
1554
1555     default:
1556         return FALSE;
1557     }
1558 }
1559