diff options
| -rw-r--r-- | ChangeLog | 12 | ||||
| -rw-r--r-- | linuxthreads/ChangeLog | 1 | ||||
| -rw-r--r-- | linuxthreads/Versions | 3 | ||||
| -rw-r--r-- | linuxthreads/semaphore.c | 125 | ||||
| -rw-r--r-- | linuxthreads/semaphore.h | 10 | ||||
| -rw-r--r-- | locale/programs/localedef.c | 4 | ||||
| -rw-r--r-- | malloc/Versions | 4 | ||||
| -rw-r--r-- | malloc/mcheck.c | 95 | ||||
| -rw-r--r-- | malloc/mcheck.h | 9 |
9 files changed, 255 insertions, 8 deletions
diff --git a/ChangeLog b/ChangeLog index 4655cc37c0..70d4a9d8ea 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,15 @@ +2000-03-26 Ulrich Drepper <drepper@redhat.com> + + * include/features.h: Undef and document __USE_XOPEN2K. + + * malloc/mcheck.c: Implement pedantic checking of all allocated blocks + whenever a function is called. Initiated by calling mcheck_pedantic + instead of mcheck. + * malloc/mcheck.h: Declare mcheck_pedantic. + * malloc/Versions [libc] (GLIBC_2.2): Add mcheck_pedantic. + * locale/programs/localdef.c: Use mcheck_pedantic instead of mcheck + for now. + 2000-03-26 Roland McGrath <roland@baalperazim.frob.com> * dlfcn/dlopen.c: Use <shlib-compat.h> macros. diff --git a/linuxthreads/ChangeLog b/linuxthreads/ChangeLog index 2c513dc8f3..5039a12ba8 100644 --- a/linuxthreads/ChangeLog +++ b/linuxthreads/ChangeLog @@ -3,6 +3,7 @@ * semaphore.c (sem_timedwait): New function. Patch by Carl Mailloux <carlm@oricom.ca>. * semaphore.h: Declare sem_timedwait. + * Versions [libpthread] (GLIBC_2.2): Add sem_timedwait. 2000-03-26 Roland McGrath <roland@baalperazim.frob.com> diff --git a/linuxthreads/Versions b/linuxthreads/Versions index 1b9de67b67..2e3673e1a1 100644 --- a/linuxthreads/Versions +++ b/linuxthreads/Versions @@ -129,5 +129,8 @@ libpthread { __pthread_rwlock_init; __pthread_rwlock_destroy; __pthread_rwlock_rdlock; __pthread_rwlock_tryrdlock; __pthread_rwlock_wrlock; __pthread_rwlock_trywrlock; __pthread_rwlock_unlock; + + # New functions from IEEE Std. 10003.1-200x. + sem_timedwait; } } diff --git a/linuxthreads/semaphore.c b/linuxthreads/semaphore.c index c4a4f6e042..3344d0d859 100644 --- a/linuxthreads/semaphore.c +++ b/linuxthreads/semaphore.c @@ -190,6 +190,131 @@ int sem_unlink(const char *name) return -1; } +int sem_timedwait(sem_t *sem, const struct timespec *abstime) +{ + pthread_descr self = thread_self(); + pthread_extricate_if extr; + int already_canceled = 0; + int was_signalled = 0; + sigjmp_buf jmpbuf; + sigset_t unblock; + sigset_t initial_mask; + + __pthread_lock((struct _pthread_fastlock *) &sem->__sem_lock, self); + if (sem->__sem_value > 0) { + --sem->__sem_value; + __pthread_unlock((struct _pthread_fastlock *) &sem->__sem_lock); + return 0; + } + + if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000) { + /* The standard requires that if the function would block and the + time value is illegal, the function returns with an error. */ + __pthread_unlock((struct _pthread_fastlock *) &sem->__sem_lock); + return EINVAL; + } + + /* Set up extrication interface */ + extr.pu_object = sem; + extr.pu_extricate_func = new_sem_extricate_func; + + /* Register extrication interface */ + __pthread_set_own_extricate_if(self, &extr); + /* Enqueue only if not already cancelled. */ + if (!(THREAD_GETMEM(self, p_canceled) + && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE)) + enqueue(&sem->__sem_waiting, self); + else + already_canceled = 1; + __pthread_unlock((struct _pthread_fastlock *) &sem->__sem_lock); + + if (already_canceled) { + __pthread_set_own_extricate_if(self, 0); + pthread_exit(PTHREAD_CANCELED); + } + + /* Set up a longjmp handler for the restart signal, unblock + the signal and sleep. */ + + if (sigsetjmp(jmpbuf, 1) == 0) { + THREAD_SETMEM(self, p_signal_jmp, &jmpbuf); + THREAD_SETMEM(self, p_signal, 0); + /* Unblock the restart signal */ + sigemptyset(&unblock); + sigaddset(&unblock, __pthread_sig_restart); + sigprocmask(SIG_UNBLOCK, &unblock, &initial_mask); + + while (1) { + struct timeval now; + struct timespec reltime; + + /* Compute a time offset relative to now. */ + __gettimeofday (&now, NULL); + reltime.tv_nsec = abstime->tv_nsec - now.tv_usec * 1000; + reltime.tv_sec = abstime->tv_sec - now.tv_sec; + if (reltime.tv_nsec < 0) { + reltime.tv_nsec += 1000000000; + reltime.tv_sec -= 1; + } + + /* Sleep for the required duration. If woken by a signal, + resume waiting as required by Single Unix Specification. */ + if (reltime.tv_sec < 0 || __libc_nanosleep(&reltime, NULL) == 0) + break; + } + + /* Block the restart signal again */ + sigprocmask(SIG_SETMASK, &initial_mask, NULL); + was_signalled = 0; + } else { + was_signalled = 1; + } + THREAD_SETMEM(self, p_signal_jmp, NULL); + + /* Now was_signalled is true if we exited the above code + due to the delivery of a restart signal. In that case, + everything is cool. We have been removed from the queue + by the other thread, and consumed its signal. + + Otherwise we this thread woke up spontaneously, or due to a signal other + than restart. The next thing to do is to try to remove the thread + from the queue. This may fail due to a race against another thread + trying to do the same. In the failed case, we know we were signalled, + and we may also have to consume a restart signal. */ + + if (!was_signalled) { + int was_on_queue; + + /* __pthread_lock will queue back any spurious restarts that + may happen to it. */ + + __pthread_lock((struct _pthread_fastlock *)&sem->__sem_lock, self); + was_on_queue = remove_from_queue(&sem->__sem_waiting, self); + __pthread_unlock((struct _pthread_fastlock *)&sem->__sem_lock); + + if (was_on_queue) { + __pthread_set_own_extricate_if(self, 0); + return ETIMEDOUT; + } + + /* Eat the outstanding restart() from the signaller */ + suspend(self); + } + __pthread_set_own_extricate_if(self, 0); + + /* Terminate only if the wakeup came from cancellation. */ + /* Otherwise ignore cancellation because we got the semaphore. */ + + if (THREAD_GETMEM(self, p_woken_by_cancel) + && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) { + THREAD_SETMEM(self, p_woken_by_cancel, 0); + pthread_exit(PTHREAD_CANCELED); + } + /* We got the semaphore */ + return 0; +} + + versioned_symbol (libpthread, __new_sem_init, sem_init, GLIBC_2_1); versioned_symbol (libpthread, __new_sem_wait, sem_wait, GLIBC_2_1); versioned_symbol (libpthread, __new_sem_trywait, sem_trywait, GLIBC_2_1); diff --git a/linuxthreads/semaphore.h b/linuxthreads/semaphore.h index 21a9deaafe..583b65ea18 100644 --- a/linuxthreads/semaphore.h +++ b/linuxthreads/semaphore.h @@ -17,6 +17,10 @@ #include <features.h> #include <sys/types.h> +#ifdef __USE_XOPEN2K +# define __need_timespec +# include <time.h> +#endif #ifndef _PTHREAD_DESCR_DEFINED /* Thread descriptors. Needed for `sem_t' definition. */ @@ -66,6 +70,12 @@ extern int sem_unlink (__const char *__name) __THROW; /* Wait for SEM being posted. */ extern int sem_wait (sem_t *__sem) __THROW; +#ifdef __USE_XOPEN2K +/* Similar to `sem_wait' but wait only until ABSTIME. */ +extern int sem_timedwait (sem_t *__sem, __const struct timespec *__abstime) + __THROW; +#endif + /* Test whether SEM is posted. */ extern int sem_trywait (sem_t *__sem) __THROW; diff --git a/locale/programs/localedef.c b/locale/programs/localedef.c index 86b8bff5da..9def7a38ad 100644 --- a/locale/programs/localedef.c +++ b/locale/programs/localedef.c @@ -1,4 +1,4 @@ -/* Copyright (C) 1995, 1996, 1997, 1998, 1999 Free Software Foundation, Inc. +/* Copyright (C) 1995,1996,1997,1998,1999,2000 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Ulrich Drepper <drepper@cygnus.com>, 1995. @@ -136,7 +136,7 @@ main (int argc, char *argv[]) int remaining; /* Enable `malloc' debugging. */ - mcheck (NULL); + mcheck_pedantic (NULL); /* Set initial values for global variables. */ copy_list = NULL; diff --git a/malloc/Versions b/malloc/Versions index 1a4454f22e..43207549a6 100644 --- a/malloc/Versions +++ b/malloc/Versions @@ -48,4 +48,8 @@ libc { # Special functions. __libc_freeres; } + GLIBC_2.2 { + # m* + mcheck_pedantic; + } } diff --git a/malloc/mcheck.c b/malloc/mcheck.c index 85258e9dd0..42e8e71174 100644 --- a/malloc/mcheck.c +++ b/malloc/mcheck.c @@ -1,5 +1,5 @@ /* Standard debugging hooks for `malloc'. - Copyright (C) 1990,91,92,93,94,95,96,97,99 Free Software Foundation, Inc. + Copyright (C) 1990-1997, 1999, 2000 Free Software Foundation, Inc. Written May 1989 by Mike Haertel. This library is free software; you can redistribute it and/or @@ -24,6 +24,7 @@ # define _MALLOC_INTERNAL # include <malloc.h> # include <mcheck.h> +# include <stdint.h> # include <stdio.h> # include <libintl.h> #endif @@ -46,10 +47,19 @@ static void (*abortfunc) __P ((enum mcheck_status)); struct hdr { - __malloc_size_t size; /* Exact size requested by user. */ + __malloc_size_t size; /* Exact size requested by user. */ unsigned long int magic; /* Magic number to check header integrity. */ + struct hdr *prev; + struct hdr *next; }; +/* This is the beginning of the list of all memory blocks allocated. + It is only constructed if the pedantic testing is requested. */ +static struct hdr *root; + +/* Nonzero if pedentic checking of all blocks is requested. */ +static int pedantic; + #if defined _LIBC || defined STDC_HEADERS || defined USG # include <string.h> # define flood memset @@ -73,7 +83,7 @@ checkhdr (hdr) const struct hdr *hdr; { enum mcheck_status status; - switch (hdr->magic) + switch (hdr->magic ^ ((uintptr_t) hdr->prev + (uintptr_t) hdr->next)) { default: status = MCHECK_HEAD; @@ -93,17 +103,77 @@ checkhdr (hdr) return status; } +static void check_all __P ((void)); +static void +check_all () +{ + /* Walk through all the active blocks and test whether they were tempered + with. */ + struct hdr *runp = root; + + while (runp != NULL) + { + (void) checkhdr (runp); + + runp = runp->next; + } +} + +static void unlink_blk __P ((struct hdr *ptr)); +static void +unlink_blk (ptr) + struct hdr *ptr; +{ + if (ptr->next != NULL) + { + ptr->next->prev = ptr->prev; + ptr->next->magic = MAGICWORD ^ ((uintptr_t) ptr->next->prev + + (uintptr_t) ptr->next->next); + } + if (ptr->prev != NULL) + { + ptr->prev->next = ptr->next; + ptr->prev->magic = MAGICWORD ^ ((uintptr_t) ptr->prev->prev + + (uintptr_t) ptr->prev->next); + } + else + root = ptr->next; +} + +static void link_blk __P ((struct hdr *ptr)); +static void +link_blk (hdr) + struct hdr *hdr; +{ + hdr->prev = NULL; + hdr->next = root; + root = hdr; + hdr->magic = MAGICWORD ^ (uintptr_t) hdr->next; + + /* And the next block. */ + if (hdr->next != NULL) + { + hdr->next->prev = hdr; + hdr->next->magic = MAGICWORD ^ ((uintptr_t) hdr + + (uintptr_t) hdr->next->next); + } +} + static void freehook __P ((__ptr_t, const __ptr_t)); static void freehook (ptr, caller) __ptr_t ptr; const __ptr_t caller; { + if (pedantic) + check_all (); if (ptr) { struct hdr *hdr = ((struct hdr *) ptr) - 1; checkhdr (hdr); hdr->magic = MAGICFREE; + unlink_blk (hdr); + hdr->prev = hdr->next = NULL; flood (ptr, FREEFLOOD, hdr->size); ptr = (__ptr_t) hdr; } @@ -123,6 +193,9 @@ mallochook (size, caller) { struct hdr *hdr; + if (pedantic) + check_all (); + __malloc_hook = old_malloc_hook; if (old_malloc_hook != NULL) hdr = (struct hdr *) (*old_malloc_hook) (sizeof (struct hdr) + size + 1, @@ -134,7 +207,7 @@ mallochook (size, caller) return NULL; hdr->size = size; - hdr->magic = MAGICWORD; + link_blk (hdr); ((char *) &hdr[1])[size] = MAGICBYTE; flood ((__ptr_t) (hdr + 1), MALLOCFLOOD, size); return (__ptr_t) (hdr + 1); @@ -150,12 +223,16 @@ reallochook (ptr, size, caller) struct hdr *hdr; __malloc_size_t osize; + if (pedantic) + check_all (); + if (ptr) { hdr = ((struct hdr *) ptr) - 1; osize = hdr->size; checkhdr (hdr); + unlink_blk (hdr); if (size < osize) flood ((char *) ptr + size, FREEFLOOD, osize - size); } @@ -181,7 +258,7 @@ reallochook (ptr, size, caller) return NULL; hdr->size = size; - hdr->magic = MAGICWORD; + link_blk (hdr); ((char *) &hdr[1])[size] = MAGICBYTE; if (size > osize) flood ((char *) (hdr + 1) + osize, MALLOCFLOOD, size - osize); @@ -244,6 +321,14 @@ mcheck (func) return mcheck_used ? 0 : -1; } +int +mcheck_pedantic (func) + void (*func) __P ((enum mcheck_status)); +{ + pedantic = 1; + return mcheck (func); +} + enum mcheck_status mprobe (__ptr_t ptr) { diff --git a/malloc/mcheck.h b/malloc/mcheck.h index 5cf2bcd598..9460547d08 100644 --- a/malloc/mcheck.h +++ b/malloc/mcheck.h @@ -1,4 +1,4 @@ -/* Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc. +/* Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or @@ -41,6 +41,13 @@ enum mcheck_status null, the standard function prints on stderr and then calls `abort'. */ extern int mcheck (void (*__abortfunc) (enum mcheck_status)) __THROW; +/* Similar to `mcheck´ but performs checks for all block whenever one of + the memory handling functions is called. This can be very slow. */ +extern int mcheck_pedantic (void (*__abortfunc) (enum mcheck_status)) __THROW; + +/* Similar to `mcheck', but perform tests on all blocks every time. */ +extern int mcheck_verbose (void (*func) __P ((enum mcheck_status))); + /* Check for aberrations in a particular malloc'd block. You must have called `mcheck' already. These are the same checks that `mcheck' does when you free or reallocate a block. */ |