From 40cf527fe65e12a745ca7b981676da1fb691eee6 Mon Sep 17 00:00:00 2001 From: rpj Date: Sun, 19 Jul 1998 16:48:18 +0000 Subject: Mon Jul 20 02:31:05 1998 Ross Johnson * private.c (_pthread_getthreadindex): Implement. * pthread.h: Add application static data dependent on _PTHREADS_BUILD_DLL define. This is needed to avoid allocating non-sharable static data within the pthread DLL. * implement.h: Add _pthread_cleanup_stack_t, _pthread_cleanup_node_t and _PTHREAD_HASH_INDEX. * exit.c (pthread_exit): Begin work on cleanup and de-allocate thread-private storage. * create.c (pthread_create): Add thread to thread table. Keep a thread-private copy of the attributes with default values filled in when necessary. Same for the cleanup stack. Make pthread_create C run-time library friendly by using _beginthreadex() instead of CreateThread(). Fix error returns. Sun Jul 19 16:26:23 1998 Ross Johnson * implement.h: Rename pthreads_thread_count to _pthread_threads_count. Create _pthread_threads_thread_t struct to keep thread specific data. * create.c: Rename pthreads_thread_count to _pthread_threads_count. (pthread_create): Handle errors from CreateThread(). --- create.c | 142 +++++++++++++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 110 insertions(+), 32 deletions(-) (limited to 'create.c') diff --git a/create.c b/create.c index 7a374bb..6897a9f 100644 --- a/create.c +++ b/create.c @@ -6,23 +6,24 @@ * thread. */ +#include +#include #include "pthread.h" #include "implement.h" -/* FIXME: There must be a Win32 routine to get this value. */ -DWORD pthread_threads_count = 0; - int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void * (*start_routine) (void *), void * arg) { /* Call Win32 CreateThread. Map attributes as correctly as possible. + The passed in attr structure will be modified by this routine + to reflect any default values used. This is POSIX semantics. */ - HANDLE handle; - DWORD flags = 0; /* Always 0 for POSIX threads */ - DWORD stack = PTHREAD_STACK_MIN; - LPSECURITY_ATTRIBUTES security = NULL; + HANDLE handle = NULL; + unsigned flags; + unsigned stack; + void * security = NULL; /* FIXME: This needs to be moved into process space. Perhaps into a structure that contains all @@ -32,34 +33,111 @@ pthread_create(pthread_t *thread, const pthread_attr_t *attr, */ SECURITY_ATTRIBUTES security_attr; DWORD threadID; + int t; + int ret = 0; /* Success unless otherwise set */ + char * privmem; + pthread_attr_t * attr_copy; + _pthread_cleanup_stack_t * cleanup_stack; + + /* Use and modify attr_copy. Only after we've succeeded in creating the + new thread can we modify any passed-in structures. - if (pthread_threads_count >= PTHREAD_THREADS_MAX) + We use one malloc() to get all of our heap space and then allocate + it further. + */ + if (NULL == (privmem = (char) malloc(sizeof(pthread_attr_t) + + sizeof(_pthread_cleanup_stack_t) + + sizeof(DWORD)))) { return EAGAIN; + } + + attr_copy = (pthread_attr_t *) privmem; + /* Force the next to a DWORD boundary. + This is all compile time arithmetic. + */ + cleanup_stack = + (_pthread_cleanup_stack_t *) &privmem[((sizeof(pthread_attr_t) / + sizeof(DWORD)) + 1) + * sizeof(DWORD)]; + + (void) memcpy(attr_copy, attr); + + + /* CRITICAL SECTION */ + pthread_mutex_lock(&_pthread_count_mutex); + + if (_pthread_threads_count < PTHREAD_THREADS_MAX) { + switch (attr) + { + case NULL: + /* Use POSIX default attributes */ + stack = attr_copy->stacksize = PTHREAD_STACK_MIN; + break; + default: + /* Map attributes */ + if (attr_copy.stacksize != NULL) + stack = (DWORD) attr_copy->stacksize; + else + stack = attr_copy->stacksize = PTHREAD_STACK_MIN; + break; + } + + flags = 1; /* Start suspended and resume at the last moment */ - switch (attr) - { - case NULL: - /* Use POSIX default attributes */ - break; - default: - /* Map attributes */ - if (attr->stacksize != NULL) - stack = (DWORD) attr->stacksize; - break; + handle = (HANDLE) _beginthreadex(security, + stack, + (unsigned (_stdcall *)(void *)) start_routine, + arg, + flags, + &threadID); + + if (handle != NULL) { + /* We have a new thread */ + _pthread_threads_count++; + + /* The hash table works as follows: + hash into the table, + if the slot is occupied then start single stepping from there + until we find an available slot. + + There is at least one slot available at this point. + */ + t = _PTHREAD_HASH_INDEX(handle); + while ((_pthread_threads_table[t])->thread != NULL) { + t++; + if (t == PTHREAD_THREADS_MAX) + t = 0; /* Wrap around to the first slot */ + } + if ((_pthread_threads_table[t])->thread != NULL) { + /* INTERNAL ERROR */ + } else { + (_pthread_threads_table[t])->thread = handle; + (_pthread_threads_table[t])->attr = attr_copy; + (_pthread_threads_table[t])->cleanupstack = cleanup_stack; + } + } else { + ret = EAGAIN; } + } else { + ret = EAGAIN; + } - /* FIXME: I don't have error return values to work with so - I'm assuming this always succeeds (obviously not). - */ - handle = CreateThread(security, - stack, - start_routine, - arg, - flags, - &threadID); - - *thread = (pthread_t) handle; - pthread_threads_count++; - return 0; -} + /* Let others in as soon as possible. */ + pthread_mutex_unlock(&_pthread_count_mutex); + /* END CRITICAL SECTION */ + + if (ret == 0) { + *thread = (pthread_t) handle; + (void) memcpy(attr, attr_copy); + /* POSIX threads are always running after creation. + Start the thread only after passed-in structures have been + modified to avoid race conditions. + */ + ResumeThread(handle); + } else { + free(privmem); + } + + return ret; +} -- cgit v1.2.3