r820@NOME-KING: raeburn | 2008-08-26 18:37:41 -0400
authorKen Raeburn <raeburn@mit.edu>
Wed, 27 Aug 2008 00:21:53 +0000 (00:21 +0000)
committerKen Raeburn <raeburn@mit.edu>
Wed, 27 Aug 2008 00:21:53 +0000 (00:21 +0000)
 x
 r821@NOME-KING:  raeburn | 2008-08-26 18:51:10 -0400
 Remove disabled statistics gathering support.
 r822@NOME-KING:  raeburn | 2008-08-26 18:57:20 -0400
 Remove source location tracking.
 r823@NOME-KING:  raeburn | 2008-08-26 19:05:35 -0400
 Delete DEBUG_THREADS code.
 r824@NOME-KING:  raeburn | 2008-08-26 19:18:59 -0400
 Remove now-no-op assertion checks.
 r825@NOME-KING:  raeburn | 2008-08-26 19:29:49 -0400
 Simplify some wrappers.
 r826@NOME-KING:  raeburn | 2008-08-26 19:38:23 -0400
 Remove redundant comment.
 r827@NOME-KING:  raeburn | 2008-08-26 19:49:20 -0400
 When pthreads must be checked for at run time, don't include the no-op _nothread_mutex stuff too.
 r828@NOME-KING:  raeburn | 2008-08-26 19:54:05 -0400
 Remove remaining DEBUG_THREADS bits.
 r829@NOME-KING:  raeburn | 2008-08-26 20:00:22 -0400
 fix up initializer
 r830@NOME-KING:  raeburn | 2008-08-26 20:10:37 -0400
 Flatten a couple of structs wrapping single elements.
 r831@NOME-KING:  raeburn | 2008-08-26 20:14:01 -0400
 Remove k5_pthread_mutex_*lock macros.
 r832@NOME-KING:  raeburn | 2008-08-26 20:19:14 -0400
 Update comments a bit for lack of debug support.

git-svn-id: svn://anonsvn.mit.edu/krb5/trunk@20696 dc483132-0cff-0310-8789-dd5450dbe970

src/include/k5-thread.h
src/util/et/error_message.c
src/util/support/libkrb5support-fixed.exports
src/util/support/threads.c

index c688988803d0e57a902dfd1975c69058b112dc5b..c70f634d4d0d8f18b3917e518fa9f906565a76de 100644 (file)
@@ -48,9 +48,6 @@
    //            finish does nothing
    //   Windows: partial initializer is an invalid handle,
    //            finish does the real initialization work
-   //   debug:   partial initializer sets one magic value,
-   //            finish verifies and sets a new magic value for
-   //              lock/unlock to check
    k5_mutex_t foo_mutex = K5_MUTEX_PARTIAL_INITIALIZER;
    int k5_mutex_finish_init(k5_mutex_t *);
    // for dynamic allocation
 
    A second function or macro called at various possible "first" entry
    points which either calls pthread_once on the first function
-   (POSIX), or checks some flag set by the first function (Windows,
-   debug support), and possibly returns an error.  (In the
-   non-threaded case, a simple flag can be used to avoid multiple
-   invocations, and the mutexes don't need run-time initialization
-   anyways.)
+   (POSIX), or checks some flag set by the first function (Windows),
+   and possibly returns an error.  (In the non-threaded case, a simple
+   flag can be used to avoid multiple invocations, and the mutexes
+   don't need run-time initialization anyways.)
 
    A third function for library termination calls mutex_destroy on
    each mutex for the library.  This function would be called
    The TSD destructor table is global state, protected by a mutex if
    threads are enabled.
 
-   Debug support: Not much.  Might check if k5_key_register has been
-   called and abort if not.
-
 
    Any actual external symbols will use the krb5int_ prefix.  The k5_
    names will be simple macros or inline functions to rename the
 
    More to be added, perhaps.  */
 
-#undef DEBUG_THREADS
-#undef DEBUG_THREADS_LOC
-#undef DEBUG_THREADS_STATS
-
 #include <assert.h>
-\f
-/* For tracking locations, of (e.g.) last lock or unlock of mutex.  */
-#ifdef DEBUG_THREADS_LOC
-typedef struct {
-    const char *filename;
-    int lineno;
-} k5_debug_loc;
-#define K5_DEBUG_LOC_INIT      { __FILE__, __LINE__ }
-#if __GNUC__ >= 2
-#define K5_DEBUG_LOC           (__extension__ (k5_debug_loc)K5_DEBUG_LOC_INIT)
-#else
-static inline k5_debug_loc k5_debug_make_loc(const char *file, int line)
-{
-    k5_debug_loc l;
-    l.filename = file;
-    l.lineno = line;
-    return l;
-}
-#define K5_DEBUG_LOC           (k5_debug_make_loc(__FILE__,__LINE__))
-#endif
-#else /* ! DEBUG_THREADS_LOC */
-typedef int k5_debug_loc;
-#define K5_DEBUG_LOC_INIT      0
-#define K5_DEBUG_LOC           0
-#endif
-
-#define k5_debug_update_loc(L) ((L) = K5_DEBUG_LOC)
-
-\f
-
-/* Statistics gathering:
-
-   Currently incomplete, don't try enabling it.
-
-   Eventually: Report number of times locked, total and standard
-   deviation of the time the lock was held, total and std dev time
-   spent waiting for the lock.  "Report" will probably mean "write a
-   line to a file if a magic environment variable is set."  */
-
-#ifdef DEBUG_THREADS_STATS
-
-#if HAVE_TIME_H && (!defined(HAVE_SYS_TIME_H) || defined(TIME_WITH_SYS_TIME))
-# include <time.h>
-#endif
-#if HAVE_SYS_TIME_H
-# include <sys/time.h>
-#endif
-#ifdef HAVE_STDINT_H
-# include <stdint.h>
-#endif
-/* for memset */
-#include <string.h>
-/* for uint64_t */
-#include <inttypes.h>
-typedef uint64_t k5_debug_timediff_t; /* or long double */
-typedef struct timeval k5_debug_time_t;
-static inline k5_debug_timediff_t
-timediff(k5_debug_time_t t2, k5_debug_time_t t1)
-{
-    return (t2.tv_sec - t1.tv_sec) * 1000000 + (t2.tv_usec - t1.tv_usec);
-}
-static inline k5_debug_time_t get_current_time(void)
-{
-    struct timeval tv;
-    if (gettimeofday(&tv,0) < 0) { tv.tv_sec = tv.tv_usec = 0; }
-    return tv;
-}
-struct k5_timediff_stats {
-    k5_debug_timediff_t valmin, valmax, valsum, valsqsum;
-};
-typedef struct {
-    int count;
-    k5_debug_time_t time_acquired, time_created;
-    struct k5_timediff_stats lockwait, lockheld;
-} k5_debug_mutex_stats;
-#define k5_mutex_init_stats(S)                                 \
-       (memset((S), 0, sizeof(k5_debug_mutex_stats)),  \
-        (S)->time_created = get_current_time(),                \
-        0)
-#define k5_mutex_finish_init_stats(S)  (0)
-#define K5_MUTEX_STATS_INIT    { 0, {0}, {0}, {0}, {0} }
-typedef k5_debug_time_t k5_mutex_stats_tmp;
-#define k5_mutex_stats_start() get_current_time()
-void KRB5_CALLCONV krb5int_mutex_lock_update_stats(k5_debug_mutex_stats *m,
-                                                  k5_mutex_stats_tmp start);
-void KRB5_CALLCONV krb5int_mutex_unlock_update_stats(k5_debug_mutex_stats *m);
-#define k5_mutex_lock_update_stats     krb5int_mutex_lock_update_stats
-#define k5_mutex_unlock_update_stats   krb5int_mutex_unlock_update_stats
-void KRB5_CALLCONV krb5int_mutex_report_stats(/* k5_mutex_t *m */);
-
-#else
-
-typedef char k5_debug_mutex_stats;
-#define k5_mutex_init_stats(S)         (*(S) = 's', 0)
-#define k5_mutex_finish_init_stats(S)  (0)
-#define K5_MUTEX_STATS_INIT            's'
-typedef int k5_mutex_stats_tmp;
-#define k5_mutex_stats_start()         (0)
-#ifdef __GNUC__
-static inline void
-k5_mutex_lock_update_stats(k5_debug_mutex_stats *m __attribute__((unused)),
-                          k5_mutex_stats_tmp t __attribute__((unused)))
-{
-}
-#else
-# define k5_mutex_lock_update_stats(M,S)       (S)
-#endif
-#define k5_mutex_unlock_update_stats(M)        (*(M) = 's')
-
-/* If statistics tracking isn't enabled, these functions don't actually
-   do anything.  Declare anyways so we can do type checking etc.  */
-void KRB5_CALLCONV krb5int_mutex_lock_update_stats(k5_debug_mutex_stats *m,
-                                                  k5_mutex_stats_tmp start);
-void KRB5_CALLCONV krb5int_mutex_unlock_update_stats(k5_debug_mutex_stats *m);
-void KRB5_CALLCONV krb5int_mutex_report_stats(/* k5_mutex_t *m */);
-
-#define krb5int_mutex_report_stats(M)  ((M)->stats = 'd')
-
-#endif
-
 \f
 
-/* The mutex structure we use, k5_mutex_t, has some OS-specific bits,
-   and some non-OS-specific bits for debugging and profiling.
+/* The mutex structure we use, k5_mutex_t, is defined to some
+   OS-specific bits.  The use of multiple layers of typedefs are an
+   artifact resulting from debugging code we once used, implemented as
+   wrappers around the OS mutex scheme.
 
    The OS specific bits, in k5_os_mutex, break down into three primary
    implementations, POSIX threads, Windows threads, and no thread
@@ -289,59 +160,6 @@ void KRB5_CALLCONV krb5int_mutex_report_stats(/* k5_mutex_t *m */);
 
 /* Define the OS mutex bit.  */
 
-/* First, if we're not actually doing multiple threads, do we
-   want the debug support or not?  */
-
-#ifdef DEBUG_THREADS
-
-enum k5_mutex_init_states {
-    K5_MUTEX_DEBUG_PARTLY_INITIALIZED = 0x12,
-    K5_MUTEX_DEBUG_INITIALIZED,
-    K5_MUTEX_DEBUG_DESTROYED
-};
-enum k5_mutex_flag_states {
-    K5_MUTEX_DEBUG_UNLOCKED = 0x23,
-    K5_MUTEX_DEBUG_LOCKED
-};
-
-typedef struct {
-    enum k5_mutex_init_states initialized;
-    enum k5_mutex_flag_states locked;
-} k5_os_nothread_mutex;
-
-# define K5_OS_NOTHREAD_MUTEX_PARTIAL_INITIALIZER \
-       { K5_MUTEX_DEBUG_PARTLY_INITIALIZED, K5_MUTEX_DEBUG_UNLOCKED }
-
-# define k5_os_nothread_mutex_finish_init(M)                           \
-       (assert((M)->initialized != K5_MUTEX_DEBUG_INITIALIZED),        \
-        assert((M)->initialized == K5_MUTEX_DEBUG_PARTLY_INITIALIZED), \
-        assert((M)->locked == K5_MUTEX_DEBUG_UNLOCKED),                \
-        (M)->initialized = K5_MUTEX_DEBUG_INITIALIZED, 0)
-# define k5_os_nothread_mutex_init(M)                  \
-       ((M)->initialized = K5_MUTEX_DEBUG_INITIALIZED, \
-        (M)->locked = K5_MUTEX_DEBUG_UNLOCKED, 0)
-# define k5_os_nothread_mutex_destroy(M)                               \
-       (assert((M)->initialized == K5_MUTEX_DEBUG_INITIALIZED),        \
-        (M)->initialized = K5_MUTEX_DEBUG_DESTROYED, 0)
-
-# define k5_os_nothread_mutex_lock(M)                  \
-       (k5_os_nothread_mutex_assert_unlocked(M),       \
-        (M)->locked = K5_MUTEX_DEBUG_LOCKED, 0)
-# define k5_os_nothread_mutex_unlock(M)                        \
-       (k5_os_nothread_mutex_assert_locked(M),         \
-        (M)->locked = K5_MUTEX_DEBUG_UNLOCKED, 0)
-
-# define k5_os_nothread_mutex_assert_locked(M)                         \
-       (assert((M)->initialized == K5_MUTEX_DEBUG_INITIALIZED),        \
-        assert((M)->locked != K5_MUTEX_DEBUG_UNLOCKED),                \
-        assert((M)->locked == K5_MUTEX_DEBUG_LOCKED))
-# define k5_os_nothread_mutex_assert_unlocked(M)                       \
-       (assert((M)->initialized == K5_MUTEX_DEBUG_INITIALIZED),        \
-        assert((M)->locked != K5_MUTEX_DEBUG_LOCKED),                  \
-        assert((M)->locked == K5_MUTEX_DEBUG_UNLOCKED))
-
-#else /* threads disabled and not debugging */
-
 typedef char k5_os_nothread_mutex;
 # define K5_OS_NOTHREAD_MUTEX_PARTIAL_INITIALIZER      0
 /* Empty inline functions avoid the "statement with no effect"
@@ -362,10 +180,6 @@ static inline int k5_os_nothread_mutex_lock(k5_os_nothread_mutex *m) {
 static inline int k5_os_nothread_mutex_unlock(k5_os_nothread_mutex *m) {
     return 0;
 }
-# define k5_os_nothread_mutex_assert_locked(M)         ((void)0)
-# define k5_os_nothread_mutex_assert_unlocked(M)       ((void)0)
-
-#endif
 
 /* Values:
    2 - function has not been run
@@ -390,8 +204,6 @@ typedef k5_os_nothread_mutex k5_os_mutex;
 # define k5_os_mutex_destroy           k5_os_nothread_mutex_destroy
 # define k5_os_mutex_lock              k5_os_nothread_mutex_lock
 # define k5_os_mutex_unlock            k5_os_nothread_mutex_unlock
-# define k5_os_mutex_assert_locked     k5_os_nothread_mutex_assert_locked
-# define k5_os_mutex_assert_unlocked   k5_os_nothread_mutex_assert_unlocked
 
 # define k5_once_t                     k5_os_nothread_once_t
 # define K5_ONCE_INIT                  K5_OS_NOTHREAD_ONCE_INIT
@@ -448,29 +260,6 @@ extern int krb5int_pthread_loaded(void)
 #endif
      ;
 # define K5_PTHREADS_LOADED    (krb5int_pthread_loaded())
-#else
-/* no pragma weak support */
-# define K5_PTHREADS_LOADED    (1)
-#endif
-
-#if defined(__mips) && defined(__sgi) && (defined(_SYSTYPE_SVR4) || defined(__SYSTYPE_SVR4__))
-/* IRIX 6.5 stub pthread support in libc is really annoying.  The
-   pthread_mutex_lock function returns ENOSYS for a program not linked
-   against -lpthread.  No link-time failure, no weak reference tests,
-   etc.
-
-   The C library doesn't provide pthread_once; we can use weak
-   reference support for that.  */
-# ifndef HAVE_PRAGMA_WEAK_REF
-#  if defined(__GNUC__) && __GNUC__ < 3
-#   error "Please update to a newer gcc with weak symbol support, or switch to native cc, reconfigure and recompile."
-#  else
-#   error "Weak reference support is required"
-#  endif
-# endif
-#endif
-
-#if defined(HAVE_PRAGMA_WEAK_REF) && !defined(NO_WEAK_PTHREADS)
 # define USE_PTHREAD_LOCK_ONLY_IF_LOADED
 
 /* Can't rely on useful stubs -- see above regarding Solaris.  */
@@ -482,131 +271,51 @@ typedef struct {
 # define k5_once(O,F)  (K5_PTHREADS_LOADED                     \
                         ? pthread_once(&(O)->o,F)              \
                         : k5_os_nothread_once(&(O)->n,F))
+
 #else
+
+/* no pragma weak support */
+# define K5_PTHREADS_LOADED    (1)
+
 typedef pthread_once_t k5_once_t;
 # define K5_ONCE_INIT  PTHREAD_ONCE_INIT
 # define k5_once       pthread_once
-#endif
 
-typedef struct {
-    pthread_mutex_t p;
-#ifdef DEBUG_THREADS
-    pthread_t owner;
-#endif
-#ifdef USE_PTHREAD_LOCK_ONLY_IF_LOADED
-    k5_os_nothread_mutex n;
 #endif
-} k5_os_mutex;
 
-#ifdef DEBUG_THREADS
-# ifdef __GNUC__
-#  define k5_pthread_mutex_lock(M)                     \
-       __extension__ ({                                \
-           k5_os_mutex *_m2 = (M);                     \
-           int _r2 = pthread_mutex_lock(&_m2->p);      \
-           if (_r2 == 0) _m2->owner = pthread_self();  \
-           _r2;                                        \
-       })
-# else
-static inline int
-k5_pthread_mutex_lock(k5_os_mutex *m)
-{
-    int r = pthread_mutex_lock(&m->p);
-    if (r)
-       return r;
-    m->owner = pthread_self();
-    return 0;
-}
+#if defined(__mips) && defined(__sgi) && (defined(_SYSTYPE_SVR4) || defined(__SYSTYPE_SVR4__))
+# ifndef HAVE_PRAGMA_WEAK_REF
+#  if defined(__GNUC__) && __GNUC__ < 3
+#   error "Please update to a newer gcc with weak symbol support, or switch to native cc, reconfigure and recompile."
+#  else
+#   error "Weak reference support is required"
+#  endif
 # endif
-# define k5_pthread_assert_locked(M)                           \
-       (K5_PTHREADS_LOADED                                     \
-        ? assert(pthread_equal((M)->owner, pthread_self()))    \
-        : (void)0)
-# define k5_pthread_mutex_unlock(M)    \
-       (k5_pthread_assert_locked(M),   \
-        (M)->owner = (pthread_t) 0,    \
-        pthread_mutex_unlock(&(M)->p))
-#else
-# define k5_pthread_mutex_lock(M) pthread_mutex_lock(&(M)->p)
-static inline void k5_pthread_assert_locked(k5_os_mutex *m) { }
-# define k5_pthread_mutex_unlock(M) pthread_mutex_unlock(&(M)->p)
 #endif
 
-/* Define as functions to:
-   (1) eliminate "statement with no effect" warnings for "0"
-   (2) encourage type-checking in calling code  */
-
-static inline void k5_pthread_assert_unlocked(pthread_mutex_t *m) { }
+typedef pthread_mutex_t k5_os_mutex;
+# define K5_OS_MUTEX_PARTIAL_INITIALIZER \
+       PTHREAD_MUTEX_INITIALIZER
 
 #ifdef USE_PTHREAD_LOCK_ONLY_IF_LOADED
 
-# if defined(PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP) && defined(DEBUG_THREADS)
-#  define K5_OS_MUTEX_PARTIAL_INITIALIZER \
-       { PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP, (pthread_t) 0, \
-         K5_OS_NOTHREAD_MUTEX_PARTIAL_INITIALIZER }
-# elif defined(DEBUG_THREADS)
-#  define K5_OS_MUTEX_PARTIAL_INITIALIZER \
-       { PTHREAD_MUTEX_INITIALIZER, (pthread_t) 0, \
-         K5_OS_NOTHREAD_MUTEX_PARTIAL_INITIALIZER }
-# else
-#  define K5_OS_MUTEX_PARTIAL_INITIALIZER \
-       { PTHREAD_MUTEX_INITIALIZER, K5_OS_NOTHREAD_MUTEX_PARTIAL_INITIALIZER }
-# endif
-
-# define k5_os_mutex_finish_init(M)            \
-       k5_os_nothread_mutex_finish_init(&(M)->n)
+# define k5_os_mutex_finish_init(M)            (0)
 # define k5_os_mutex_init(M)                   \
-       (k5_os_nothread_mutex_init(&(M)->n),    \
-        (K5_PTHREADS_LOADED                    \
-         ? pthread_mutex_init(&(M)->p, 0)      \
-         : 0))
+       (K5_PTHREADS_LOADED ? pthread_mutex_init((M), 0) : 0)
 # define k5_os_mutex_destroy(M)                        \
-       (k5_os_nothread_mutex_destroy(&(M)->n), \
-        (K5_PTHREADS_LOADED                    \
-         ? pthread_mutex_destroy(&(M)->p)      \
-         : 0))
-
-# define k5_os_mutex_lock(M)                           \
-       (K5_PTHREADS_LOADED                             \
-        ? k5_pthread_mutex_lock(M)                     \
-        : k5_os_nothread_mutex_lock(&(M)->n))
-# define k5_os_mutex_unlock(M)                         \
-       (K5_PTHREADS_LOADED                             \
-        ? k5_pthread_mutex_unlock(M)                   \
-        : k5_os_nothread_mutex_unlock(&(M)->n))
-
-# define k5_os_mutex_assert_unlocked(M)                        \
-       (K5_PTHREADS_LOADED                             \
-        ? k5_pthread_assert_unlocked(&(M)->p)          \
-        : k5_os_nothread_mutex_assert_unlocked(&(M)->n))
-# define k5_os_mutex_assert_locked(M)                  \
-       (K5_PTHREADS_LOADED                             \
-        ? k5_pthread_assert_locked(M)                  \
-        : k5_os_nothread_mutex_assert_locked(&(M)->n))
+       (K5_PTHREADS_LOADED ? pthread_mutex_destroy((M)) : 0)
+# define k5_os_mutex_lock(M)                   \
+       (K5_PTHREADS_LOADED ? pthread_mutex_lock(M) : 0)
+# define k5_os_mutex_unlock(M)                 \
+       (K5_PTHREADS_LOADED ? pthread_mutex_unlock(M) : 0)
 
 #else
 
-# ifdef DEBUG_THREADS
-#  ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
-#   define K5_OS_MUTEX_PARTIAL_INITIALIZER \
-       { PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP, (pthread_t) 0 }
-#  else
-#   define K5_OS_MUTEX_PARTIAL_INITIALIZER \
-       { PTHREAD_MUTEX_INITIALIZER, (pthread_t) 0 }
-#  endif
-# else
-#  define K5_OS_MUTEX_PARTIAL_INITIALIZER \
-       { PTHREAD_MUTEX_INITIALIZER }
-# endif
-
 static inline int k5_os_mutex_finish_init(k5_os_mutex *m) { return 0; }
-# define k5_os_mutex_init(M)           pthread_mutex_init(&(M)->p, 0)
-# define k5_os_mutex_destroy(M)                pthread_mutex_destroy(&(M)->p)
-# define k5_os_mutex_lock(M)           k5_pthread_mutex_lock(M)
-# define k5_os_mutex_unlock(M)         k5_pthread_mutex_unlock(M)
-
-# define k5_os_mutex_assert_unlocked(M)        k5_pthread_assert_unlocked(&(M)->p)
-# define k5_os_mutex_assert_locked(M)  k5_pthread_assert_locked(M)
+# define k5_os_mutex_init(M)           pthread_mutex_init((M), 0)
+# define k5_os_mutex_destroy(M)                pthread_mutex_destroy((M))
+# define k5_os_mutex_lock(M)           pthread_mutex_lock(M)
+# define k5_os_mutex_unlock(M)         pthread_mutex_unlock(M)
 
 #endif /* is pthreads always available? */
 
@@ -650,9 +359,6 @@ static inline int k5_os_mutex_lock(k5_os_mutex *m)
         (M)->is_locked = 0,                            \
         ReleaseMutex((M)->h) ? 0 : GetLastError())
 
-# define k5_os_mutex_assert_unlocked(M)        ((void)0)
-# define k5_os_mutex_assert_locked(M)  ((void)0)
-
 #else
 
 # error "Thread support enabled, but thread system unknown"
@@ -662,66 +368,33 @@ static inline int k5_os_mutex_lock(k5_os_mutex *m)
 
 \f
 
-typedef struct {
-    k5_debug_loc loc_last, loc_created;
-    k5_os_mutex os;
-    k5_debug_mutex_stats stats;
-} k5_mutex_t;
-#define K5_MUTEX_PARTIAL_INITIALIZER           \
-       { K5_DEBUG_LOC_INIT, K5_DEBUG_LOC_INIT, \
-         K5_OS_MUTEX_PARTIAL_INITIALIZER, K5_MUTEX_STATS_INIT }
-static inline int k5_mutex_init_1(k5_mutex_t *m, k5_debug_loc l)
+typedef k5_os_mutex k5_mutex_t;
+#define K5_MUTEX_PARTIAL_INITIALIZER   K5_OS_MUTEX_PARTIAL_INITIALIZER
+static inline int k5_mutex_init(k5_mutex_t *m)
 {
-    int err = k5_os_mutex_init(&m->os);
-    if (err) return err;
-    m->loc_created = m->loc_last = l;
-    err = k5_mutex_init_stats(&m->stats);
-    assert(err == 0);
-    return 0;
+    return k5_os_mutex_init(m);
 }
-#define k5_mutex_init(M)       k5_mutex_init_1((M), K5_DEBUG_LOC)
-static inline int k5_mutex_finish_init_1(k5_mutex_t *m, k5_debug_loc l)
+static inline int k5_mutex_finish_init(k5_mutex_t *m)
 {
-    int err = k5_os_mutex_finish_init(&m->os);
-    if (err) return err;
-    m->loc_created = m->loc_last = l;
-    err = k5_mutex_finish_init_stats(&m->stats);
-    assert(err == 0);
-    return 0;
+    return k5_os_mutex_finish_init(m);
 }
-#define k5_mutex_finish_init(M)        k5_mutex_finish_init_1((M), K5_DEBUG_LOC)
 #define k5_mutex_destroy(M)                    \
-       (k5_os_mutex_assert_unlocked(&(M)->os), \
-        krb5int_mutex_report_stats(M),         \
-        !k5_mutex_lock(M) && ((M)->loc_last = K5_DEBUG_LOC, k5_mutex_unlock(M)), \
-        k5_os_mutex_destroy(&(M)->os))
+    (k5_os_mutex_destroy(M))
 
 #if __GNUC__ >= 4
-static int k5_mutex_lock_1(k5_mutex_t *, k5_debug_loc)
+static int k5_mutex_lock(k5_mutex_t *)
     __attribute__((warn_unused_result));
 #endif
-static inline int k5_mutex_lock_1(k5_mutex_t *m, k5_debug_loc l)
+static inline int k5_mutex_lock(k5_mutex_t *m)
 {
-    int err = 0;
-    k5_mutex_stats_tmp stats = k5_mutex_stats_start();
-    err = k5_os_mutex_lock(&m->os);
-    if (err)
-       return err;
-    m->loc_last = l;
-    k5_mutex_lock_update_stats(&m->stats, stats);
-    return err;
+    return k5_os_mutex_lock(m);
 }
-#define k5_mutex_lock(M)       k5_mutex_lock_1(M, K5_DEBUG_LOC)
 
 #define k5_mutex_unlock(M)                             \
-       (k5_mutex_assert_locked(M),                     \
-        k5_mutex_unlock_update_stats(&(M)->stats),     \
-        (M)->loc_last = K5_DEBUG_LOC,                  \
-        k5_os_mutex_unlock(&(M)->os))
-
-#define k5_mutex_assert_locked(M)      k5_os_mutex_assert_locked(&(M)->os)
-#define k5_mutex_assert_unlocked(M)    k5_os_mutex_assert_unlocked(&(M)->os)
+       (k5_os_mutex_unlock(M))
 
+#define k5_mutex_assert_locked(M)      ((void)(M))
+#define k5_mutex_assert_unlocked(M)    ((void)(M))
 #define k5_assert_locked       k5_mutex_assert_locked
 #define k5_assert_unlocked     k5_mutex_assert_unlocked
 
index 1cd982e14e01f525e8dd716d459c0aaa7728f6c0..d9485cdd7582151ca047591af058d79b2909a2ba 100644 (file)
@@ -321,12 +321,6 @@ remove_error_table(const struct error_table * et)
 
     if (CALL_INIT_FUNCTION(com_err_initialize))
        return 0;
-#if !defined(ENABLE_THREADS) && defined(DEBUG_THREADS)
-    if (et_list_lock.os.initialized == 0 && terminated != 0) {
-       fprintf(stderr, "\n\n *** Function remove_error_table called after com_err library termination. ***\n *** Shared library termination code executed in incorrect order?          ***\n\n");
-       abort();
-    }
-#endif
     merr = k5_mutex_lock(&et_list_lock);
     if (merr)
        return merr;
index 850db8c641eb4b4bb24d4780a1dd7c5c409179d0..225c54ac0546ad71dec5354b96c3d9e05182bb28 100644 (file)
@@ -2,9 +2,6 @@ krb5int_key_register
 krb5int_key_delete
 krb5int_getspecific
 krb5int_setspecific
-krb5int_mutex_lock_update_stats
-krb5int_mutex_unlock_update_stats
-krb5int_mutex_report_stats
 krb5int_getaddrinfo
 krb5int_freeaddrinfo
 krb5int_gai_strerror
index b30989df1cee1188c9cd8c86098d06f94461e600..316be8a1cbb8750e3928efb1f0d5c3407e6a987b 100644 (file)
@@ -412,11 +412,6 @@ int krb5int_call_thread_support_init (void)
 
 #include "cache-addrinfo.h"
 
-#ifdef DEBUG_THREADS_STATS
-#include <stdio.h>
-static FILE *stats_logfile;
-#endif
-
 int krb5int_thread_support_init (void)
 {
     int err;
@@ -425,15 +420,6 @@ int krb5int_thread_support_init (void)
     printf("krb5int_thread_support_init\n");
 #endif
 
-#ifdef DEBUG_THREADS_STATS
-    /*    stats_logfile = stderr; */
-    stats_logfile = fopen("/dev/tty", "w+");
-    if (stats_logfile == NULL)
-       stats_logfile = stderr;
-    else
-       set_cloexec_file(stats_logfile);
-#endif
-
 #ifndef ENABLE_THREADS
 
     /* Nothing to do for TLS initialization.  */
@@ -498,127 +484,9 @@ void krb5int_thread_support_fini (void)
 
 #endif
 
-#ifdef DEBUG_THREADS_STATS
-    fflush(stats_logfile);
-    /* XXX Should close if not stderr, in case unloading library but
-       not exiting.  */
-#endif
-
     krb5int_fini_fac();
 }
 
-#ifdef DEBUG_THREADS_STATS
-void KRB5_CALLCONV
-k5_mutex_lock_update_stats(k5_debug_mutex_stats *m,
-                          k5_mutex_stats_tmp startwait)
-{
-  k5_debug_time_t now;
-  k5_debug_timediff_t tdiff, tdiff2;
-
-  now = get_current_time();
-  (void) krb5int_call_thread_support_init();
-  m->count++;
-  m->time_acquired = now;
-  tdiff = timediff(now, startwait);
-  tdiff2 = tdiff * tdiff;
-  if (m->count == 1 || m->lockwait.valmin > tdiff)
-    m->lockwait.valmin = tdiff;
-  if (m->count == 1 || m->lockwait.valmax < tdiff)
-    m->lockwait.valmax = tdiff;
-  m->lockwait.valsum += tdiff;
-  m->lockwait.valsqsum += tdiff2;
-}
-
-void KRB5_CALLCONV
-krb5int_mutex_unlock_update_stats(k5_debug_mutex_stats *m)
-{
-  k5_debug_time_t now = get_current_time();
-  k5_debug_timediff_t tdiff, tdiff2;
-  tdiff = timediff(now, m->time_acquired);
-  tdiff2 = tdiff * tdiff;
-  if (m->count == 1 || m->lockheld.valmin > tdiff)
-    m->lockheld.valmin = tdiff;
-  if (m->count == 1 || m->lockheld.valmax < tdiff)
-    m->lockheld.valmax = tdiff;
-  m->lockheld.valsum += tdiff;
-  m->lockheld.valsqsum += tdiff2;
-}
-
-#include <math.h>
-static inline double
-get_stddev(struct k5_timediff_stats sp, int count)
-{
-  long double mu, mu_squared, rho_squared;
-  mu = (long double) sp.valsum / count;
-  mu_squared = mu * mu;
-  /* SUM((x_i - mu)^2)
-     = SUM(x_i^2 - 2*mu*x_i + mu^2)
-     = SUM(x_i^2) - 2*mu*SUM(x_i) + N*mu^2
-
-     Standard deviation rho^2 = SUM(...) / N.  */
-  rho_squared = (sp.valsqsum - 2 * mu * sp.valsum + count * mu_squared) / count;
-  return sqrt(rho_squared);
-}
-
-void KRB5_CALLCONV
-krb5int_mutex_report_stats(k5_mutex_t *m)
-{
-  char *p;
-
-  /* Tweak this to only record data on "interesting" locks.  */
-  if (m->stats.count < 10)
-    return;
-  if (m->stats.lockwait.valsum < 10 * m->stats.count)
-    return;
-
-  p = strrchr(m->loc_created.filename, '/');
-  if (p == NULL)
-    p = m->loc_created.filename;
-  else
-    p++;
-  fprintf(stats_logfile, "mutex @%p: created at line %d of %s\n",
-         (void *) m, m->loc_created.lineno, p);
-  if (m->stats.count == 0)
-    fprintf(stats_logfile, "\tnever locked\n");
-  else {
-    double sd_wait, sd_hold;
-    sd_wait = get_stddev(m->stats.lockwait, m->stats.count);
-    sd_hold = get_stddev(m->stats.lockheld, m->stats.count);
-    fprintf(stats_logfile,
-           "\tlocked %d time%s; wait %lu/%f/%lu/%fus, hold %lu/%f/%lu/%fus\n",
-           m->stats.count, m->stats.count == 1 ? "" : "s",
-           (unsigned long) m->stats.lockwait.valmin,
-           (double) m->stats.lockwait.valsum / m->stats.count,
-           (unsigned long) m->stats.lockwait.valmax,
-           sd_wait,
-           (unsigned long) m->stats.lockheld.valmin,
-           (double) m->stats.lockheld.valsum / m->stats.count,
-           (unsigned long) m->stats.lockheld.valmax,
-           sd_hold);
-  }
-}
-#else
-/* On Windows, everything defined in the export list must be defined.
-   The UNIX systems where we're using the export list don't seem to
-   care.  */
-#undef krb5int_mutex_lock_update_stats
-void KRB5_CALLCONV
-krb5int_mutex_lock_update_stats(k5_debug_mutex_stats *m,
-                               k5_mutex_stats_tmp startwait)
-{
-}
-#undef krb5int_mutex_unlock_update_stats
-void KRB5_CALLCONV
-krb5int_mutex_unlock_update_stats(k5_debug_mutex_stats *m)
-{
-}
-#undef krb5int_mutex_report_stats
-void KRB5_CALLCONV
-krb5int_mutex_report_stats(k5_mutex_t *m)
-{
-}
-#endif
-
 /* Mutex allocation functions, for use in plugins that may not know
    what options a given set of libraries was compiled with.  */
 int KRB5_CALLCONV