From fdacb17d4819c7112a147195c5ce3c82147f4b46 Mon Sep 17 00:00:00 2001 From: Ulrich Drepper Date: Mon, 29 Jun 1998 12:44:22 +0000 Subject: Update. 1998-06-29 12:27 Ulrich Drepper * argp/argp.h: Use __PMT instead of __P for function pointer. * iconv/gconv.h: Likewise. * io/fts.h: Likewise. * io/ftw.h: Likewise. * libio/libio.h: Likewise. * malloc/mcheck.h: Likewise. * misc/search.h: Likewise. * posix/glob.h: Likewise. * resolv/resolv.h: Likewise. * signal/signal.h: Likewise. * stdlib/stdlib.h: Likewise. * sysdeps/unix/sysv/linux/bits/sigaction.h: Likewise. * sysdeps/unix/sysv/linux/bits/siginfo.h: Likewise. 1998-06-26 Andreas Schwab * Makeconfig (CPPFLAGS): Use $($(subdir)-CPPFLAGS) only once. 1998-06-27 Andreas Schwab * posix/wordexp.c (parse_param): Fix memory leak. 1998-06-27 Andreas Schwab * libc.map: Export _IO_ftrylockfile. 1998-06-27 Andreas Schwab * sysdeps/unix/sysv/linux/aio_sigqueue.c: Use get[pu]id instead of __get[pu]id. 1998-06-28 Andreas Schwab * elf/dl-misc.c (_dl_debug_message): Don't cache the pid. * elf/dl-runtime.c (_dl_object_relocation_scope): Avoid adding the same search list twice. 1998-06-29 Andreas Jaeger * login/programs/utmpd.c (handle_requests): Set and use maximal fd used to optimize loop/select. 1998-06-24 Andreas Schwab * sysdeps/generic/init-first.c: Don't define __libc_pid. * sysdeps/unix/sysv/linux/init-first.c: Likewise. * sysdeps/mach/hurd/i386/init-first.c: Likewise. * sysdeps/mach/hurd/mips/init-first.c: Likewise. * sysdeps/arm/init-first.c: Likewise. * posix/getopt_init.c: Don't use __libc_pid. * sysdeps/unix/sysv/linux/aio_sigqueue.c: Likewise. * sysdeps/unix/sysv/linux/sigqueue.c: Likewise. * libc.map: Remove __libc_uid and __libc_pid. --- linuxthreads/ChangeLog | 27 +++++++++++++++ linuxthreads/internals.h | 6 ++-- linuxthreads/join.c | 4 +-- linuxthreads/libpthread.map | 18 +++++----- linuxthreads/manager.c | 61 ++++++++-------------------------- linuxthreads/pthread.c | 5 +++ linuxthreads/sysdeps/pthread/pthread.h | 26 +++++++++++++-- 7 files changed, 83 insertions(+), 64 deletions(-) (limited to 'linuxthreads') diff --git a/linuxthreads/ChangeLog b/linuxthreads/ChangeLog index ead990b382..05c842a65f 100644 --- a/linuxthreads/ChangeLog +++ b/linuxthreads/ChangeLog @@ -1,3 +1,30 @@ +1998-06-29 12:34 Ulrich Drepper + + * sysdeps/pthread/pthread.h: Use __PMT not __P for function pointers. + + * sysdeps/pthread/pthread.h: Define various PTHREAD_* symbols also + as macros as demanded in POSIX.1, Annex C. + +1998-06-29 12:29 Ulrich Drepper + + * internals.h (struct pthread_request): For free use pthread_t + instead of pthread_descr. + * join.c (pthread_join): Pass thread_id, not th to manager. + (pthread_detach): Likewise. + * manager.c (__pthread_manager): Except thread ID in FREE_REQ case. + (pthread_exited): Remove detached queue code. + (pthread_handle_free): Expect thread ID parameter and use it to + validate the thread decsriptor. Don't use detached queue. + Patches by Xavier Leroy. + +1998-06-27 Andreas Schwab + + * libpthread.map: Export accept, longjmp, sigaction, siglongjmp, + _IO_flockfile, _IO_ftrylockfile, _IO_funlockfile, + __pthread_atfork, __pthread_key_create, __pthread_once. + * internals.h: Doc fix. + * pthread.c (__pthread_initialize): Define again. + 1998-06-26 Ulrich Drepper * manager.c (pthread_exited): If thread is not detached put it on diff --git a/linuxthreads/internals.h b/linuxthreads/internals.h index 0a01b61ede..9d6f2fadcf 100644 --- a/linuxthreads/internals.h +++ b/linuxthreads/internals.h @@ -86,7 +86,7 @@ struct _pthread_descr_struct { struct pthread_start_args p_start_args; /* arguments for thread creation */ void ** p_specific[PTHREAD_KEY_1STLEVEL_SIZE]; /* thread-specific data */ void * p_libc_specific[_LIBC_TSD_KEY_N]; /* thread-specific data for libc */ - int p_userstack; /* nonzero if the user provided the thread */ + int p_userstack; /* nonzero if the user provided the stack */ void *p_guardaddr; /* address of guard area or NULL */ size_t p_guardsize; /* size of guard area */ }; @@ -117,7 +117,7 @@ struct pthread_request { sigset_t mask; /* signal mask */ } create; struct { /* For REQ_FREE: */ - pthread_descr thread; /* descriptor of thread to free */ + pthread_t thread_id; /* identifier of thread to free */ } free; struct { /* For REQ_PROCESS_EXIT: */ int code; /* exit status */ @@ -171,7 +171,7 @@ extern char *__pthread_initial_thread_bos; extern int __pthread_nonstandard_stacks; /* File descriptor for sending requests to the thread manager. - Initially -1, meaning that pthread_initialize must be called. */ + Initially -1, meaning that __pthread_initialize_manager must be called. */ extern int __pthread_manager_request; diff --git a/linuxthreads/join.c b/linuxthreads/join.c index c59de6985a..4fadd85299 100644 --- a/linuxthreads/join.c +++ b/linuxthreads/join.c @@ -99,7 +99,7 @@ int pthread_join(pthread_t thread_id, void ** thread_return) if (__pthread_manager_request >= 0) { request.req_thread = self; request.req_kind = REQ_FREE; - request.req_args.free.thread = th; + request.req_args.free.thread_id = thread_id; __libc_write(__pthread_manager_request, (char *) &request, sizeof(request)); } @@ -137,7 +137,7 @@ int pthread_detach(pthread_t thread_id) if (terminated && __pthread_manager_request >= 0) { request.req_thread = thread_self(); request.req_kind = REQ_FREE; - request.req_args.free.thread = th; + request.req_args.free.thread_id = thread_id; __libc_write(__pthread_manager_request, (char *) &request, sizeof(request)); } diff --git a/linuxthreads/libpthread.map b/linuxthreads/libpthread.map index b7dd1670d5..8174f7d95d 100644 --- a/linuxthreads/libpthread.map +++ b/linuxthreads/libpthread.map @@ -8,11 +8,13 @@ GLIBC_2.0 { __libc_internal_tsd_get; __libc_internal_tsd_set; # Overwritten libc functions. - close; connect; fcntl; fork; fsync; lseek; msync; nanosleep; open; - pause; raise; read; recv; recvfrom; recvmsg; send; sendmsg; sendto; - system; tcdrain; wait; waitpid; write; + accept; close; connect; fcntl; fork; fsync; longjmp; lseek; msync; + nanosleep; open; pause; raise; read; recv; recvfrom; recvmsg; send; + sendmsg; sendto; sigaction; siglongjmp; system; tcdrain; wait; + waitpid; write; __close; __connect; __fcntl; __lseek; __open; __read; __send; __wait; __write; + _IO_flockfile; _IO_ftrylockfile; _IO_funlockfile; # POSIX.1c extensions to libc. flockfile; funlockfile; ftrylockfile; @@ -43,11 +45,11 @@ GLIBC_2.0 { sigwait; # Protected names for functions used in other shared objects. - __pthread_getspecific; __pthread_initialize; __pthread_mutex_destroy; - __pthread_mutex_init; __pthread_mutex_lock; __pthread_mutex_trylock; - __pthread_mutex_unlock; __pthread_mutexattr_destroy; - __pthread_mutexattr_init; __pthread_mutexattr_setkind_np; - __pthread_setspecific; + __pthread_atfork; __pthread_initialize; __pthread_getspecific; + __pthread_key_create; __pthread_mutex_destroy; __pthread_mutex_init; + __pthread_mutex_lock; __pthread_mutex_trylock; __pthread_mutex_unlock; + __pthread_mutexattr_destroy; __pthread_mutexattr_init; + __pthread_mutexattr_setkind_np; __pthread_once; __pthread_setspecific; # The error functions. __errno_location; __h_errno_location; diff --git a/linuxthreads/manager.c b/linuxthreads/manager.c index 39c103cdc4..e69abac009 100644 --- a/linuxthreads/manager.c +++ b/linuxthreads/manager.c @@ -37,12 +37,6 @@ struct pthread_handle_struct __pthread_handles[PTHREAD_THREADS_MAX] = { { LOCK_INITIALIZER, &__pthread_initial_thread, 0}, /* All NULLs */ }; -/* This is a list of terminated, but not detached threads. This can happen - when pthread_join() is called and the pthread_reap_children() function - removes the thread from the live list before processing the FREE_REQ - request. */ -static pthread_descr non_detached; - /* Indicate whether at least one thread has a user-defined stack (if 1), or if all threads have stacks supplied by LinuxThreads (if 0). */ int __pthread_nonstandard_stacks = 0; @@ -83,7 +77,7 @@ static pthread_t pthread_threads_counter = 0; static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr, void * (*start_routine)(void *), void *arg, sigset_t *mask, int father_pid); -static void pthread_handle_free(pthread_descr th); +static void pthread_handle_free(pthread_t th_id); static void pthread_handle_exit(pthread_descr issuing_thread, int exitcode); static void pthread_reap_children(void); static void pthread_kill_all_threads(int sig, int main_thread_also); @@ -149,7 +143,7 @@ int __pthread_manager(void *arg) restart(request.req_thread); break; case REQ_FREE: - pthread_handle_free(request.req_args.free.thread); + pthread_handle_free(request.req_args.free.thread_id); break; case REQ_PROCESS_EXIT: pthread_handle_exit(request.req_thread, @@ -406,14 +400,6 @@ static void pthread_exited(pid_t pid) __pthread_unlock(th->p_lock); if (detached) pthread_free(th); - else { - /* Enqueue in the detached list. */ - th->p_nextlive = non_detached; - if (non_detached != NULL) - non_detached->p_prevlive = th; - th->p_prevlive = NULL; - non_detached = th; - } break; } } @@ -445,49 +431,28 @@ static void pthread_reap_children(void) /* Try to free the resources of a thread when requested by pthread_join or pthread_detach on a terminated thread. */ -static void pthread_handle_free(pthread_descr th) +static void pthread_handle_free(pthread_t th_id) { - pthread_descr t; - /* Check that the thread th is still there -- pthread_reap_children - might have deallocated it already */ - t = __pthread_main_thread; - do { - if (t == th) break; - t = t->p_nextlive; - } while (t != __pthread_main_thread); - if (t != th) { - /* Hum, it might be that the thread already was dequeued but - wasn't detached. In the case the thread is already detached - and we cannot find it this is a user bug but we must be - gracious. */ - t = non_detached; - while (t != NULL) { - if (t == th) break; - t = t->p_nextlive; - } - if (t == th) { - if (th->p_prevlive == NULL) - non_detached = th->p_nextlive; - else - th->p_prevlive->p_nextlive = th->p_nextlive; - if (th->p_nextlive != NULL) - th->p_nextlive->p_prevlive = th->p_prevlive; + pthread_handle handle = thread_handle(th_id); + pthread_descr th; - /* Finally free it. */ - pthread_free (th); - } + __pthread_lock(&handle->h_lock); + if (invalid_handle(handle, th_id)) { + /* pthread_reap_children has deallocated the thread already, + nothing needs to be done */ + __pthread_unlock(&handle->h_lock); return; } - __pthread_lock(th->p_lock); + th = handle->h_descr; if (th->p_exited) { - __pthread_unlock(th->p_lock); + __pthread_unlock(&handle->h_lock); pthread_free(th); } else { /* The Unix process of the thread is still running. Mark the thread as detached so that the thread manager will deallocate its resources when the Unix process exits. */ th->p_detached = 1; - __pthread_unlock(th->p_lock); + __pthread_unlock(&handle->h_lock); } } diff --git a/linuxthreads/pthread.c b/linuxthreads/pthread.c index e95b352b72..4e8a9f1dd7 100644 --- a/linuxthreads/pthread.c +++ b/linuxthreads/pthread.c @@ -215,6 +215,11 @@ static void pthread_initialize(void) __on_exit(pthread_exit_process, NULL); } +void __pthread_initialize(void) +{ + pthread_initialize(); +} + int __pthread_initialize_manager(void) { int manager_pipe[2]; diff --git a/linuxthreads/sysdeps/pthread/pthread.h b/linuxthreads/sysdeps/pthread/pthread.h index b76c4a8d5b..7e98123f43 100644 --- a/linuxthreads/sysdeps/pthread/pthread.h +++ b/linuxthreads/sysdeps/pthread/pthread.h @@ -100,19 +100,25 @@ typedef struct enum { PTHREAD_CREATE_JOINABLE, +#define PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_DETACHED +#define PTHREAD_CREATE_DETACHED PTHREAD_CREATE_DETACHED }; enum { PTHREAD_INHERIT_SCHED, +#define PTHREAD_INHERIT_SCHED PTHREAD_INHERIT_SCHED PTHREAD_EXPLICIT_SCHED +#define PTHREAD_EXPLICIT_SCHED PTHREAD_EXPLICIT_SCHED }; enum { PTHREAD_SCOPE_SYSTEM, +#define PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_PROCESS +#define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_PROCESS }; typedef struct @@ -156,7 +162,9 @@ typedef struct enum { PTHREAD_PROCESS_PRIVATE, +# define PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_SHARED +# define PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_SHARED }; enum @@ -187,7 +195,7 @@ typedef int pthread_once_t; struct _pthread_cleanup_buffer { - void (*routine) __P ((void *)); /* Function to call. */ + void (*routine) __PMT ((void *)); /* Function to call. */ void *arg; /* Its argument. */ int canceltype; /* Saved cancellation type. */ struct _pthread_cleanup_buffer *prev; /* Chaining of cleanup functions. */ @@ -195,8 +203,20 @@ struct _pthread_cleanup_buffer /* Cancellation */ -enum { PTHREAD_CANCEL_ENABLE, PTHREAD_CANCEL_DISABLE }; -enum { PTHREAD_CANCEL_DEFERRED, PTHREAD_CANCEL_ASYNCHRONOUS }; +enum +{ + PTHREAD_CANCEL_ENABLE, +#define PTHREAD_CANCEL_ENABLE PTHREAD_CANCEL_ENABLE + PTHREAD_CANCEL_DISABLE +#define PTHREAD_CANCEL_DISABLE PTHREAD_CANCEL_DISABLE +}; +enum +{ + PTHREAD_CANCEL_DEFERRED, +#define PTHREAD_CANCEL_DEFERRED PTHREAD_CANCEL_DEFERRED + PTHREAD_CANCEL_ASYNCHRONOUS +#define PTHREAD_CANCEL_ASYNCHRONOUS PTHREAD_CANCEL_ASYNCHRONOUS +}; #define PTHREAD_CANCELED ((void *) -1) -- cgit v1.2.3