contrib/bind-9.3/lib/isc/pthreads/mutex.c

   1 /*
   2  * Copyright (C) 2004, 2005  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 2000-2002  Internet Software Consortium.
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  10  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  11  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  12  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  13  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  14  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  15  * PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 /* $Id: mutex.c,v 1.6.26.5 2005/03/17 03:58:32 marka Exp $ */
  19
  20 #include <config.h>
  21
  22 #include <stdio.h>
  23 #include <time.h>
  24 #include <sys/time.h>
  25
  26 #include <isc/mutex.h>
  27 #include <isc/util.h>
  28
  29 #if ISC_MUTEX_PROFILE
  30
  31 /* Operations on timevals; adapted from FreeBSD's sys/time.h */
  32 #define timevalclear(tvp)      ((tvp)->tv_sec = (tvp)->tv_usec = 0)
  33 #define timevaladd(vvp, uvp)                                            \
  34         do {                                                            \
  35                 (vvp)->tv_sec += (uvp)->tv_sec;                         \
  36                 (vvp)->tv_usec += (uvp)->tv_usec;                       \
  37                 if ((vvp)->tv_usec >= 1000000) {                        \
  38                         (vvp)->tv_sec++;                                \
  39                         (vvp)->tv_usec -= 1000000;                      \
  40                 }                                                       \
  41         } while (0)
  42 #define timevalsub(vvp, uvp)                                            \
  43         do {                                                            \
  44                 (vvp)->tv_sec -= (uvp)->tv_sec;                         \
  45                 (vvp)->tv_usec -= (uvp)->tv_usec;                       \
  46                 if ((vvp)->tv_usec < 0) {                               \
  47                         (vvp)->tv_sec--;                                \
  48                         (vvp)->tv_usec += 1000000;                      \
  49                 }                                                       \
  50         } while (0)
  51
  52 #define ISC_MUTEX_MAX_LOCKERS 32
  53
  54 typedef struct {
  55         const char *            file;
  56         int                     line;
  57         unsigned                count;
  58         struct timeval          locked_total;
  59         struct timeval          wait_total;
  60 } isc_mutexlocker_t;
  61
  62 struct isc_mutexstats {
  63         const char *            file;   /* File mutex was created in. */
  64         int                     line;   /* Line mutex was created on. */
  65         unsigned                count;
  66         struct timeval          lock_t;
  67         struct timeval          locked_total;
  68         struct timeval          wait_total;
  69         isc_mutexlocker_t *     cur_locker;
  70         isc_mutexlocker_t       lockers[ISC_MUTEX_MAX_LOCKERS];
  71 };
  72
  73 #define TABLESIZE (8 * 1024)
  74 static isc_mutexstats_t stats[TABLESIZE];
  75 static isc_boolean_t stats_init = ISC_FALSE;
  76 static pthread_mutex_t statslock = PTHREAD_MUTEX_INITIALIZER;
  77
  78
  79 isc_result_t
  80 isc_mutex_init_profile(isc_mutex_t *mp, const char *file, int line) {
  81         int i;
  82
  83         if (pthread_mutex_init(&mp->mutex, NULL) != 0)
  84                 return ISC_R_UNEXPECTED;
  85
  86         RUNTIME_CHECK(pthread_mutex_lock(&statslock) == 0);
  87
  88         if (stats_init == ISC_FALSE) {
  89                 for (i = 0; i < TABLESIZE; i++) {
  90                         stats[i].file = NULL;
  91                 }
  92                 stats_init = ISC_TRUE;
  93         }
  94
  95         mp->stats = NULL;
  96         for (i = 0; i < TABLESIZE; i++) {
  97                 if (stats[i].file == NULL) {
  98                         mp->stats = &stats[i];
  99                         break;
 100                 }
 101         }
 102         RUNTIME_CHECK(mp->stats != NULL);
 103
 104         RUNTIME_CHECK(pthread_mutex_unlock(&statslock) == 0);
 105
 106         mp->stats->file = file;
 107         mp->stats->line = line;
 108         mp->stats->count = 0;
 109         timevalclear(&mp->stats->locked_total);
 110         timevalclear(&mp->stats->wait_total);
 111         for (i = 0; i < ISC_MUTEX_MAX_LOCKERS; i++) {
 112                 mp->stats->lockers[i].file = NULL;
 113                 mp->stats->lockers[i].line = 0;
 114                 mp->stats->lockers[i].count = 0;
 115                 timevalclear(&mp->stats->lockers[i].locked_total);
 116                 timevalclear(&mp->stats->lockers[i].wait_total);
 117         }
 118
 119         return ISC_R_SUCCESS;
 120 }
 121
 122 isc_result_t
 123 isc_mutex_lock_profile(isc_mutex_t *mp, const char *file, int line) {
 124         struct timeval prelock_t;
 125         struct timeval postlock_t;
 126         isc_mutexlocker_t *locker = NULL;
 127         int i;
 128
 129         gettimeofday(&prelock_t, NULL);
 130
 131         if (pthread_mutex_lock(&mp->mutex) != 0)
 132                 return (ISC_R_UNEXPECTED);
 133
 134         gettimeofday(&postlock_t, NULL);
 135         mp->stats->lock_t = postlock_t;
 136
 137         timevalsub(&postlock_t, &prelock_t);
 138
 139         mp->stats->count++;
 140         timevaladd(&mp->stats->wait_total, &postlock_t);
 141
 142         for (i = 0; i < ISC_MUTEX_MAX_LOCKERS; i++) {
 143                 if (mp->stats->lockers[i].file == NULL) {
 144                         locker = &mp->stats->lockers[i];
 145                         locker->file = file;
 146                         locker->line = line;
 147                         break;
 148                 } else if (mp->stats->lockers[i].file == file &&
 149                            mp->stats->lockers[i].line == line) {
 150                         locker = &mp->stats->lockers[i];
 151                         break;
 152                 }
 153         }
 154
 155         if (locker != NULL) {
 156                 locker->count++;
 157                 timevaladd(&locker->wait_total, &postlock_t);
 158         }
 159
 160         mp->stats->cur_locker = locker;
 161
 162         return ISC_R_SUCCESS;
 163 }
 164
 165 isc_result_t
 166 isc_mutex_unlock_profile(isc_mutex_t *mp, const char *file, int line) {
 167         struct timeval unlock_t;
 168
 169         UNUSED(file);
 170         UNUSED(line);
 171
 172         if (mp->stats->cur_locker != NULL) {
 173                 gettimeofday(&unlock_t, NULL);
 174                 timevalsub(&unlock_t, &mp->stats->lock_t);
 175                 timevaladd(&mp->stats->locked_total, &unlock_t);
 176                 timevaladd(&mp->stats->cur_locker->locked_total, &unlock_t);
 177                 mp->stats->cur_locker = NULL;
 178         }
 179
 180         return ((pthread_mutex_unlock((&mp->mutex)) == 0) ? \
 181                 ISC_R_SUCCESS : ISC_R_UNEXPECTED);
 182 }
 183
 184
 185 void
 186 isc_mutex_statsprofile(FILE *fp) {
 187         isc_mutexlocker_t *locker;
 188         int i, j;
 189         fprintf(fp, "Mutex stats (in us)\n");
 190         for (i = 0; i < TABLESIZE; i++) {
 191                 if (stats[i].file == NULL)
 192                         continue;
 193                 fprintf(fp, "%-12s %4d: %10u  %lu.%06lu %lu.%06lu\n",
 194                         stats[i].file, stats[i].line, stats[i].count,
 195                         stats[i].locked_total.tv_sec,
 196                         stats[i].locked_total.tv_usec,
 197                         stats[i].wait_total.tv_sec,
 198                         stats[i].wait_total.tv_usec
 199                         );
 200                 for (j = 0; j < ISC_MUTEX_MAX_LOCKERS; j++) {
 201                         locker = &stats[i].lockers[j];
 202                         if (locker->file == NULL)
 203                                 continue;
 204                         fprintf(fp, " %-11s %4d: %10u  %lu.%06lu %lu.%06lu\n",
 205                                 locker->file, locker->line, locker->count,
 206                                 locker->locked_total.tv_sec,
 207                                 locker->locked_total.tv_usec,
 208                                 locker->wait_total.tv_sec,
 209                                 locker->wait_total.tv_usec
 210                                 );
 211                 }
 212         }
 213 }
 214
 215 #endif /* ISC_MUTEX_PROFILE */
 216
 217 #if ISC_MUTEX_DEBUG && defined(PTHREAD_MUTEX_ERRORCHECK)
 218 isc_result_t
 219 isc_mutex_init_errcheck(isc_mutex_t *mp)
 220 {
 221         pthread_mutexattr_t attr;
 222
 223         if (pthread_mutexattr_init(&attr) != 0)
 224                 return ISC_R_UNEXPECTED;
 225
 226         if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK) != 0)
 227                 return ISC_R_UNEXPECTED;
 228
 229         if (pthread_mutex_init(mp, &attr) != 0)
 230                 return ISC_R_UNEXPECTED;
 231
 232         return ISC_R_SUCCESS;
 233 }
 234 #endif
 235
 236 #if ISC_MUTEX_DEBUG && defined(__NetBSD__) && defined(PTHREAD_MUTEX_ERRORCHECK)
 237 pthread_mutexattr_t isc__mutex_attrs = {
 238         PTHREAD_MUTEX_ERRORCHECK,       /* m_type */
 239         0                               /* m_flags, which appears to be unused. */
 240 };
 241 #endif