1 /* $NetBSD: mutex.c,v 1.1 2024/02/18 20:57:56 christos Exp $ */
2
3 /*
4 * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
5 *
6 * SPDX-License-Identifier: MPL-2.0
7 *
8 * This Source Code Form is subject to the terms of the Mozilla Public
9 * License, v. 2.0. If a copy of the MPL was not distributed with this
10 * file, you can obtain one at https://mozilla.org/MPL/2.0/.
11 *
12 * See the COPYRIGHT file distributed with this work for additional
13 * information regarding copyright ownership.
14 */
15
16 /*! \file */
17
18 #include <errno.h>
19 #include <stdbool.h>
20 #include <stdio.h>
21 #include <sys/time.h>
22 #include <time.h>
23
24 #include <isc/mutex.h>
25 #include <isc/once.h>
26 #include <isc/print.h>
27 #include <isc/strerr.h>
28 #include <isc/string.h>
29 #include <isc/util.h>
30
31 #if ISC_MUTEX_PROFILE
32
33 /*@{*/
34 /*% Operations on timevals; adapted from FreeBSD's sys/time.h */
35 #define timevalclear(tvp) ((tvp)->tv_sec = (tvp)->tv_usec = 0)
36 #define timevaladd(vvp, uvp) \
37 do { \
38 (vvp)->tv_sec += (uvp)->tv_sec; \
39 (vvp)->tv_usec += (uvp)->tv_usec; \
40 if ((vvp)->tv_usec >= 1000000) { \
41 (vvp)->tv_sec++; \
42 (vvp)->tv_usec -= 1000000; \
43 } \
44 } while (0)
45 #define timevalsub(vvp, uvp) \
46 do { \
47 (vvp)->tv_sec -= (uvp)->tv_sec; \
48 (vvp)->tv_usec -= (uvp)->tv_usec; \
49 if ((vvp)->tv_usec < 0) { \
50 (vvp)->tv_sec--; \
51 (vvp)->tv_usec += 1000000; \
52 } \
53 } while (0)
54
55 /*@}*/
56
57 #define ISC_MUTEX_MAX_LOCKERS 32
58
59 typedef struct {
60 const char *file;
61 int line;
62 unsigned count;
63 struct timeval locked_total;
64 struct timeval wait_total;
65 } isc_mutexlocker_t;
66
67 struct isc_mutexstats {
68 const char *file; /*%< File mutex was created in. */
69 int line; /*%< Line mutex was created on. */
70 unsigned count;
71 struct timeval lock_t;
72 struct timeval locked_total;
73 struct timeval wait_total;
74 isc_mutexlocker_t *cur_locker;
75 isc_mutexlocker_t lockers[ISC_MUTEX_MAX_LOCKERS];
76 };
77
78 #ifndef ISC_MUTEX_PROFTABLESIZE
79 #define ISC_MUTEX_PROFTABLESIZE (1024 * 1024)
80 #endif /* ifndef ISC_MUTEX_PROFTABLESIZE */
81 static isc_mutexstats_t stats[ISC_MUTEX_PROFTABLESIZE];
82 static int stats_next = 0;
83 static bool stats_init = false;
84 static pthread_mutex_t statslock = PTHREAD_MUTEX_INITIALIZER;
85
86 void
isc_mutex_init_profile(isc_mutex_t * mp,const char * file,int line)87 isc_mutex_init_profile(isc_mutex_t *mp, const char *file, int line) {
88 int i, err;
89
90 err = pthread_mutex_init(&mp->mutex, NULL);
91 if (err != 0) {
92 strerror_r(err, strbuf, sizeof(strbuf));
93 isc_error_fatal(file, line, "pthread_mutex_init failed: %s",
94 strbuf);
95 }
96
97 RUNTIME_CHECK(pthread_mutex_lock(&statslock) == 0);
98
99 if (!stats_init) {
100 stats_init = true;
101 }
102
103 /*
104 * If all statistics entries have been used, give up and trigger an
105 * assertion failure. There would be no other way to deal with this
106 * because we'd like to keep record of all locks for the purpose of
107 * debugging and the number of necessary locks is unpredictable.
108 * If this failure is triggered while debugging, named should be
109 * rebuilt with an increased ISC_MUTEX_PROFTABLESIZE.
110 */
111 RUNTIME_CHECK(stats_next < ISC_MUTEX_PROFTABLESIZE);
112 mp->stats = &stats[stats_next++];
113
114 RUNTIME_CHECK(pthread_mutex_unlock(&statslock) == 0);
115
116 mp->stats->file = file;
117 mp->stats->line = line;
118 mp->stats->count = 0;
119 timevalclear(&mp->stats->locked_total);
120 timevalclear(&mp->stats->wait_total);
121 for (i = 0; i < ISC_MUTEX_MAX_LOCKERS; i++) {
122 mp->stats->lockers[i].file = NULL;
123 mp->stats->lockers[i].line = 0;
124 mp->stats->lockers[i].count = 0;
125 timevalclear(&mp->stats->lockers[i].locked_total);
126 timevalclear(&mp->stats->lockers[i].wait_total);
127 }
128 }
129
130 isc_result_t
isc_mutex_lock_profile(isc_mutex_t * mp,const char * file,int line)131 isc_mutex_lock_profile(isc_mutex_t *mp, const char *file, int line) {
132 struct timeval prelock_t;
133 struct timeval postlock_t;
134 isc_mutexlocker_t *locker = NULL;
135 int i;
136
137 gettimeofday(&prelock_t, NULL);
138
139 if (pthread_mutex_lock(&mp->mutex) != 0) {
140 return (ISC_R_UNEXPECTED);
141 }
142
143 gettimeofday(&postlock_t, NULL);
144 mp->stats->lock_t = postlock_t;
145
146 timevalsub(&postlock_t, &prelock_t);
147
148 mp->stats->count++;
149 timevaladd(&mp->stats->wait_total, &postlock_t);
150
151 for (i = 0; i < ISC_MUTEX_MAX_LOCKERS; i++) {
152 if (mp->stats->lockers[i].file == NULL) {
153 locker = &mp->stats->lockers[i];
154 locker->file = file;
155 locker->line = line;
156 break;
157 } else if (mp->stats->lockers[i].file == file &&
158 mp->stats->lockers[i].line == line)
159 {
160 locker = &mp->stats->lockers[i];
161 break;
162 }
163 }
164
165 if (locker != NULL) {
166 locker->count++;
167 timevaladd(&locker->wait_total, &postlock_t);
168 }
169
170 mp->stats->cur_locker = locker;
171
172 return (ISC_R_SUCCESS);
173 }
174
175 isc_result_t
isc_mutex_unlock_profile(isc_mutex_t * mp,const char * file,int line)176 isc_mutex_unlock_profile(isc_mutex_t *mp, const char *file, int line) {
177 struct timeval unlock_t;
178
179 UNUSED(file);
180 UNUSED(line);
181
182 if (mp->stats->cur_locker != NULL) {
183 gettimeofday(&unlock_t, NULL);
184 timevalsub(&unlock_t, &mp->stats->lock_t);
185 timevaladd(&mp->stats->locked_total, &unlock_t);
186 timevaladd(&mp->stats->cur_locker->locked_total, &unlock_t);
187 mp->stats->cur_locker = NULL;
188 }
189
190 return ((pthread_mutex_unlock((&mp->mutex)) == 0) ? ISC_R_SUCCESS
191 : ISC_R_UNEXPECTED);
192 }
193
194 void
isc_mutex_statsprofile(FILE * fp)195 isc_mutex_statsprofile(FILE *fp) {
196 isc_mutexlocker_t *locker;
197 int i, j;
198
199 fprintf(fp, "Mutex stats (in us)\n");
200 for (i = 0; i < stats_next; i++) {
201 fprintf(fp, "%-12s %4d: %10u %lu.%06lu %lu.%06lu %5d\n",
202 stats[i].file, stats[i].line, stats[i].count,
203 stats[i].locked_total.tv_sec,
204 stats[i].locked_total.tv_usec,
205 stats[i].wait_total.tv_sec, stats[i].wait_total.tv_usec,
206 i);
207 for (j = 0; j < ISC_MUTEX_MAX_LOCKERS; j++) {
208 locker = &stats[i].lockers[j];
209 if (locker->file == NULL) {
210 continue;
211 }
212 fprintf(fp,
213 " %-11s %4d: %10u %lu.%06lu %lu.%06lu %5d\n",
214 locker->file, locker->line, locker->count,
215 locker->locked_total.tv_sec,
216 locker->locked_total.tv_usec,
217 locker->wait_total.tv_sec,
218 locker->wait_total.tv_usec, i);
219 }
220 }
221 }
222
223 #endif /* ISC_MUTEX_PROFILE */
224
225 #if ISC_MUTEX_DEBUG && defined(PTHREAD_MUTEX_ERRORCHECK)
226
227 static bool errcheck_initialized = false;
228 static pthread_mutexattr_t errcheck;
229 static isc_once_t once_errcheck = ISC_ONCE_INIT;
230
231 static void
initialize_errcheck(void)232 initialize_errcheck(void) {
233 RUNTIME_CHECK(pthread_mutexattr_init(&errcheck) == 0);
234 RUNTIME_CHECK(pthread_mutexattr_settype(&errcheck,
235 PTHREAD_MUTEX_ERRORCHECK) == 0);
236 errcheck_initialized = true;
237 }
238
239 void
isc_mutex_init_errcheck(isc_mutex_t * mp)240 isc_mutex_init_errcheck(isc_mutex_t *mp) {
241 isc_result_t result;
242 int err;
243
244 result = isc_once_do(&once_errcheck, initialize_errcheck);
245 RUNTIME_CHECK(result == ISC_R_SUCCESS);
246
247 err = pthread_mutex_init(mp, &errcheck);
248 if (err != 0) {
249 strerror_r(err, strbuf, sizeof(strbuf));
250 isc_error_fatal(file, line, "pthread_mutex_init failed: %s",
251 strbuf);
252 }
253 }
254 #endif /* if ISC_MUTEX_DEBUG && defined(PTHREAD_MUTEX_ERRORCHECK) */
255
256 #if ISC_MUTEX_DEBUG && defined(__NetBSD__) && defined(PTHREAD_MUTEX_ERRORCHECK)
257 pthread_mutexattr_t isc__mutex_attrs = {
258 PTHREAD_MUTEX_ERRORCHECK, /* m_type */
259 0 /* m_flags, which appears to be unused. */
260 };
261 #endif /* if ISC_MUTEX_DEBUG && defined(__NetBSD__) && \
262 * defined(PTHREAD_MUTEX_ERRORCHECK) */
263
264 #if !(ISC_MUTEX_DEBUG && defined(PTHREAD_MUTEX_ERRORCHECK)) && \
265 !ISC_MUTEX_PROFILE
266
267 #ifdef HAVE_PTHREAD_MUTEX_ADAPTIVE_NP
268 static bool attr_initialized = false;
269 static pthread_mutexattr_t attr;
270 static isc_once_t once_attr = ISC_ONCE_INIT;
271 #endif /* HAVE_PTHREAD_MUTEX_ADAPTIVE_NP */
272
273 #ifdef HAVE_PTHREAD_MUTEX_ADAPTIVE_NP
274 static void
initialize_attr(void)275 initialize_attr(void) {
276 RUNTIME_CHECK(pthread_mutexattr_init(&attr) == 0);
277 RUNTIME_CHECK(pthread_mutexattr_settype(
278 &attr, PTHREAD_MUTEX_ADAPTIVE_NP) == 0);
279 attr_initialized = true;
280 }
281 #endif /* HAVE_PTHREAD_MUTEX_ADAPTIVE_NP */
282
283 void
isc__mutex_init(isc_mutex_t * mp,const char * file,unsigned int line)284 isc__mutex_init(isc_mutex_t *mp, const char *file, unsigned int line) {
285 int err;
286
287 #ifdef HAVE_PTHREAD_MUTEX_ADAPTIVE_NP
288 isc_result_t result = ISC_R_SUCCESS;
289 result = isc_once_do(&once_attr, initialize_attr);
290 RUNTIME_CHECK(result == ISC_R_SUCCESS);
291
292 err = pthread_mutex_init(mp, &attr);
293 #else /* HAVE_PTHREAD_MUTEX_ADAPTIVE_NP */
294 err = pthread_mutex_init(mp, ISC__MUTEX_ATTRS);
295 #endif /* HAVE_PTHREAD_MUTEX_ADAPTIVE_NP */
296 if (err != 0) {
297 char strbuf[ISC_STRERRORSIZE];
298 strerror_r(err, strbuf, sizeof(strbuf));
299 isc_error_fatal(file, line, "pthread_mutex_init failed: %s",
300 strbuf);
301 }
302 }
303 #endif /* if !(ISC_MUTEX_DEBUG && defined(PTHREAD_MUTEX_ERRORCHECK)) && \
304 * !ISC_MUTEX_PROFILE */
305