From 0749394433f301cccd22d280cee1dd760b72e876 Mon Sep 17 00:00:00 2001 From: rpj Date: Mon, 28 Dec 1998 23:01:00 +0000 Subject: With this update I'm able to build the library and build and run the tsd1.c test successfully using buildlib.bat and build.bat scripts. I not convinced that I understand the relationships between "__cplusplus" and "_WIN32" and the MS compiler, particularly in pthread.h where pthread_cleanup_push etc is defined. In particular, I have assumed that the __try/__finally blocks are only available if _WIN32 and __cplusplus are defined. I suspect this is wrong. Tue Dec 29 13:11:16 1998 Ross Johnson * implement.h: Move the following struct definitions to pthread.h: pthread_t_, pthread_attr_t_, pthread_mutex_t_, pthread_mutex_t_, pthread_mutexattr_t_, pthread_key_t_, pthread_cond_t_, pthread_condattr_t_, pthread_once_t_. * pthread.h: Add "_" prefix to pthread_push_cleanup and pthread_pop_cleanup internal routines, and associated struct and typedefs. * buildlib.bat: Add compile command for semaphore.c * pthread.def: Comment out pthread_atfork routine name. Now unimplemented. * tsd.c (pthread_setspecific): Rename tkAssocCreate to _pthread_tkAssocCreate. (pthread_key_delete): Rename tkAssocDestroy to _pthread_tkAssocDestroy. * sync.c (pthread_join): Rename threadDestroy to _pthread_threadDestroy * sched.c (is_attr): attr is now **attr (was *attr), so add extra NULL pointer test. (pthread_attr_setschedparam): Increase redirection for attr which is now a **. (pthread_attr_getschedparam): Ditto. (pthread_setschedparam): Change thread validation and rename "thread" Win32 thread Handle element name to match John Bossom's version. (pthread_getschedparam): Ditto. * private.c (_pthread_threadDestroy): Rename call to callUserDestroyRoutines() as _pthread_callUserDestroyRoutines() * misc.c: Add #include "implement.h". * dll.c: Remove defined(KLUDGE) wrapped code. * fork.c: Remove redefinition of ENOMEM. Remove pthread_atfork() and fork() with #if 0/#endif. * create.c (pthread_create): Rename threadStart and threadDestroy calls to _pthread_threadStart and _pthread_threadDestroy. * implement.h: Rename "detachedstate" to "detachstate". * attr.c: Rename "detachedstate" to "detachstate". Mon Dec 28 09:54:39 1998 Ross Johnson * pthread.h (pthread_attr_t_): Change to *pthread_attr_t. * attr.c (pthread_attr_setstacksize): Merge with John Bossom's version. (pthread_attr_getstacksize): Merge with John Bossom's version. (pthread_attr_setstackaddr): Merge with John Bossom's version. (pthread_attr_getstackaddr): Merge with John Bossom's version. (pthread_attr_init): Merge with John Bossom's version. (pthread_attr_destroy): Merge with John Bossom's version. (pthread_attr_getdetachstate): Merge with John Bossom's version. (pthread_attr_setdetachstate): Merge with John Bossom's version. (is_attr): attr is now **attr (was *attr), so add extra NULL pointer test. * implement.h (pthread_attr_t_): Add and rename elements in JEB's version to correspond to original, so that it can be used with original attr routines. * pthread.h: Add #endif at end which was truncated in merging. --- attr.c | 354 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 338 insertions(+), 16 deletions(-) (limited to 'attr.c') diff --git a/attr.c b/attr.c index 418c3e8..33d897d 100644 --- a/attr.c +++ b/attr.c @@ -16,15 +16,57 @@ is_attr(const pthread_attr_t *attr) { /* Return 0 if the attr object is valid, non-zero otherwise. */ - return (attr == NULL || attr->valid != _PTHREAD_ATTR_VALID); + return (attr == NULL || + *attr == NULL || + (*attr)->valid != _PTHREAD_ATTR_VALID); } -#ifdef _POSIX_THREAD_ATTR_STACKSIZE int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize) + /* + * ------------------------------------------------------ + * DOCPUBLIC + * This function specifies the size of the stack on + * which threads created with 'attr' will run. + * + * PARAMETERS + * attr + * pointer to an instance of pthread_attr_t + * + * stacksize + * stack size, in bytes. + * + * + * DESCRIPTION + * This function specifies the size of the stack on + * which threads created with 'attr' will run. + * + * NOTES: + * 1) Function supported only if this macro is + * defined: + * + * _POSIX_THREAD_ATTR_STACKSIZE + * + * 2) Find the default first (using + * pthread_attr_getstacksize), then increase + * by multiplying. + * + * 3) Only use if thread needs more than the + * default. + * + * RESULTS + * 0 successfully set stack size, + * EINVAL 'attr' is invalid or stacksize too + * small or too big. + * ENOSYS function not supported + * + * ------------------------------------------------------ + */ { +#ifdef _POSIX_THREAD_ATTR_STACKSIZE + /* Verify that the stack size is within range. */ if (stacksize < PTHREAD_STACK_MIN) { @@ -37,89 +79,295 @@ pthread_attr_setstacksize(pthread_attr_t *attr, } /* Everything is okay. */ - attr->stacksize = stacksize; + (*attr)->stacksize = stacksize; return 0; + +#else + + return ENOSYS; + +#endif /* _POSIX_THREAD_ATTR_STACKSIZE */ + } int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize) + /* + * ------------------------------------------------------ + * DOCPUBLIC + * This function determines the size of the stack on + * which threads created with 'attr' will run. + * + * PARAMETERS + * attr + * pointer to an instance of pthread_attr_t + * + * stacksize + * pointer to size_t into which is returned the + * stack size, in bytes. + * + * + * DESCRIPTION + * This function determines the size of the stack on + * which threads created with 'attr' will run. + * + * NOTES: + * 1) Function supported only if this macro is + * defined: + * + * _POSIX_THREAD_ATTR_STACKSIZE + * + * 2) Use on newly created attributes object to + * find the default stack size. + * + * RESULTS + * 0 successfully retrieved stack size, + * EINVAL 'attr' is invalid + * ENOSYS function not supported + * + * ------------------------------------------------------ + */ { +#ifdef _POSIX_THREAD_ATTR_STACKSIZE + if (is_attr(attr) != 0) { return EINVAL; } /* Everything is okay. */ - *stacksize = attr->stacksize; + *stacksize = (*attr)->stacksize; return 0; -} + +#else + + return ENOSYS; #endif /* _POSIX_THREAD_ATTR_STACKSIZE */ -#ifdef _POSIX_THREAD_ATTR_STACKADDR +} + int pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr) + /* + * ------------------------------------------------------ + * DOCPUBLIC + * Threads created with 'attr' will run on the stack + * starting at 'stackaddr'. + * Stack must be at least PTHREAD_STACK_MIN bytes. + * + * PARAMETERS + * attr + * pointer to an instance of pthread_attr_t + * + * stacksize + * stack size, in bytes. + * + * + * DESCRIPTION + * Threads created with 'attr' will run on the stack + * starting at 'stackaddr'. + * Stack must be at least PTHREAD_STACK_MIN bytes. + * + * NOTES: + * 1) Function supported only if this macro is + * defined: + * + * _POSIX_THREAD_ATTR_STACKADDR + * + * 2) Create only one thread for each stack + * address.. + * + * 3) Ensure that stackaddr is aligned. + * + * RESULTS + * 0 successfully set stack address, + * EINVAL 'attr' is invalid + * ENOSYS function not supported + * + * ------------------------------------------------------ + */ { +#if defined( _POSIX_THREAD_ATTR_STACKADDR ) + if (is_attr(attr) != 0) { return EINVAL; } + + (*attr)->stackaddr = stackaddr; + return 0; + +#else + return ENOSYS; + +#endif /* _POSIX_THREAD_ATTR_STACKADDR */ } int pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr) + /* + * ------------------------------------------------------ + * DOCPUBLIC + * This function determines the address of the stack + * on which threads created with 'attr' will run. + * + * PARAMETERS + * attr + * pointer to an instance of pthread_attr_t + * + * stackaddr + * pointer into which is returned the stack address. + * + * + * DESCRIPTION + * This function determines the address of the stack + * on which threads created with 'attr' will run. + * + * NOTES: + * 1) Function supported only if this macro is + * defined: + * + * _POSIX_THREAD_ATTR_STACKADDR + * + * 2) Create only one thread for each stack + * address.. + * + * RESULTS + * 0 successfully retreived stack address, + * EINVAL 'attr' is invalid + * ENOSYS function not supported + * + * ------------------------------------------------------ + */ { +#if defined( _POSIX_THREAD_ATTR_STACKADDR ) + if (is_attr(attr) != 0) { return EINVAL; } + + *stackaddr = (*attr)->stackaddr; + return 0; + +#else + return ENOSYS; -} #endif /* _POSIX_THREAD_ATTR_STACKADDR */ +} int pthread_attr_init(pthread_attr_t *attr) + /* + * ------------------------------------------------------ + * DOCPUBLIC + * Initializes a thread attributes object with default + * attributes. + * + * PARAMETERS + * attr + * pointer to an instance of pthread_attr_t + * + * + * DESCRIPTION + * Initializes a thread attributes object with default + * attributes. + * + * NOTES: + * 1) Used to define thread attributes + * + * RESULTS + * 0 successfully initialized attr, + * ENOMEM insufficient memory for attr. + * + * ------------------------------------------------------ + */ { + pthread_attr_t attr_result; + int result = 0; + if (attr == NULL) { /* This is disallowed. */ return EINVAL; } + attr_result = malloc (sizeof (*attr_result)); + + if (attr_result == NULL) + { + return ENOMEM; + } + #ifdef _POSIX_THREAD_ATTR_STACKSIZE - attr->stacksize = PTHREAD_STACK_MIN; + attr_result->stacksize = PTHREAD_STACK_MIN; +#endif + +#ifdef _POSIX_THREAD_ATTR_STACKADDR + /* FIXME: Set this to something sensible when we support it. */ + attr_result->stackaddr = NULL; #endif - attr->detachedstate = PTHREAD_CREATE_JOINABLE; + attr_result->detachstate = PTHREAD_CREATE_JOINABLE; + #if HAVE_SIGSET_T - memset(&(attr->sigmask), 0, sizeof(sigset_t)); + memset(&(attr_result->sigmask), 0, sizeof(sigset_t)); #endif /* HAVE_SIGSET_T */ /* Priority uses Win32 priority values. */ - attr->priority = THREAD_PRIORITY_NORMAL; + attr_result->priority = THREAD_PRIORITY_NORMAL; - attr->valid = _PTHREAD_ATTR_VALID; + attr_result->valid = _PTHREAD_ATTR_VALID; + + *attr = attr_result; return 0; } int pthread_attr_destroy(pthread_attr_t *attr) + /* + * ------------------------------------------------------ + * DOCPUBLIC + * Destroys a thread attributes object. + * + * PARAMETERS + * attr + * pointer to an instance of pthread_attr_t + * + * + * DESCRIPTION + * Destroys a thread attributes object. + * + * NOTES: + * 1) Does not affect threads created with 'attr'. + * + * RESULTS + * 0 successfully destroyed attr, + * EINVAL 'attr' is invalid. + * + * ------------------------------------------------------ + */ { if (is_attr(attr) != 0) { return EINVAL; } - /* Set the attribute object to a specific invalid value. */ - attr->valid = 0; + /* + * Set the attribute object to a specific invalid value. + */ + (*attr)->valid = 0; + free (*attr); + *attr = NULL; return 0; } @@ -127,19 +375,89 @@ pthread_attr_destroy(pthread_attr_t *attr) int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate) + /* + * ------------------------------------------------------ + * DOCPUBLIC + * This function determines whether threads created with + * 'attr' will run detached. + * + * PARAMETERS + * attr + * pointer to an instance of pthread_attr_t + * + * detachstate + * pointer to an integer into which is returned one + * of: + * + * PTHREAD_CREATE_JOINABLE + * Thread ID is valid, must be joined + * + * PTHREAD_CREATE_DETACHED + * Thread ID is invalid, cannot be joined, + * canceled, or modified + * + * + * DESCRIPTION + * This function determines whether threads created with + * 'attr' will run detached. + * + * NOTES: + * 1) You cannot join or cancel detached threads. + * + * RESULTS + * 0 successfully retrieved detach state, + * EINVAL 'attr' is invalid + * + * ------------------------------------------------------ + */ { if (is_attr(attr) != 0 || detachstate == NULL) { + *detachstate = PTHREAD_CREATE_DETACHED; return EINVAL; } - *detachstate = attr->detachedstate; + *detachstate = (*attr)->detachstate; return 0; } int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate) + /* + * ------------------------------------------------------ + * DOCPUBLIC + * This function specifies whether threads created with + * 'attr' will run detached. + * + * PARAMETERS + * attr + * pointer to an instance of pthread_attr_t + * + * detachstate + * an integer containing one of: + * + * PTHREAD_CREATE_JOINABLE + * Thread ID is valid, must be joined + * + * PTHREAD_CREATE_DETACHED + * Thread ID is invalid, cannot be joined, + * canceled, or modified + * + * + * DESCRIPTION + * This function specifies whether threads created with + * 'attr' will run detached. + * + * NOTES: + * 1) You cannot join or cancel detached threads. + * + * RESULTS + * 0 successfully set detach state, + * EINVAL 'attr' or 'detachstate' is invalid + * + * ------------------------------------------------------ + */ { if (is_attr(attr) != 0) { @@ -152,6 +470,10 @@ pthread_attr_setdetachstate(pthread_attr_t *attr, return EINVAL; } - attr->detachedstate = detachstate; + (*attr)->detachstate = detachstate; return 0; } + + + + -- cgit v1.2.3