1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26 /*
27 * Copyright (c) 2012, 2014 by Delphix. All rights reserved.
28 * Copyright 2015 Joyent, Inc.
29 */
30
31 #include "lint.h"
32 #include "thr_uberdata.h"
33
34 const char *panicstr;
35 ulwp_t *panic_thread;
36
37 static mutex_t assert_lock = DEFAULTMUTEX;
38 static ulwp_t *assert_thread = NULL;
39
40 mutex_t *panic_mutex = NULL;
41
42 /*
43 * Called from __assert() to set panicstr and panic_thread.
44 */
45 void
46 __set_panicstr(const char *msg)
47 {
48 panicstr = msg;
49 panic_thread = __curthread();
50 }
51
52 /*
53 * Called from exit() (atexit function) to give precedence
54 * to assertion failures and a core dump over _exit().
55 */
56 void
57 grab_assert_lock()
58 {
59 (void) _lwp_mutex_lock(&assert_lock);
60 }
61
62 static void
63 Abort(const char *msg)
64 {
65 ulwp_t *self;
66 struct sigaction act;
67 sigset_t sigmask;
68 lwpid_t lwpid;
69
70 /* to help with core file debugging */
71 panicstr = msg;
72 if ((self = __curthread()) != NULL) {
73 panic_thread = self;
74 lwpid = self->ul_lwpid;
75 } else {
76 lwpid = _lwp_self();
77 }
78
79 /* set SIGABRT signal handler to SIG_DFL w/o grabbing any locks */
80 (void) memset(&act, 0, sizeof (act));
81 act.sa_sigaction = SIG_DFL;
82 (void) __sigaction(SIGABRT, &act, NULL);
83
84 /* delete SIGABRT from the signal mask */
85 (void) sigemptyset(&sigmask);
86 (void) sigaddset(&sigmask, SIGABRT);
87 (void) __lwp_sigmask(SIG_UNBLOCK, &sigmask);
88
89 (void) _lwp_kill(lwpid, SIGABRT); /* never returns */
90 (void) kill(getpid(), SIGABRT); /* if it does, try harder */
91 _exit(127);
92 }
93
94 /*
95 * Write a panic message w/o grabbing any locks other than assert_lock.
96 * We have no idea what locks are held at this point.
97 */
98 static void
99 common_panic(const char *head, const char *why)
100 {
101 char msg[400]; /* no panic() message in the library is this long */
102 ulwp_t *self;
103 size_t len1, len2;
104
105 if ((self = __curthread()) != NULL)
106 enter_critical(self);
107 (void) _lwp_mutex_lock(&assert_lock);
108
109 (void) memset(msg, 0, sizeof (msg));
110 (void) strcpy(msg, head);
111 len1 = strlen(msg);
112 len2 = strlen(why);
113 if (len1 + len2 >= sizeof (msg))
114 len2 = sizeof (msg) - len1 - 1;
115 (void) strncat(msg, why, len2);
116 len1 = strlen(msg);
117 if (msg[len1 - 1] != '\n')
118 msg[len1++] = '\n';
119 (void) __write(2, msg, len1);
120 Abort(msg);
121 }
122
123 void
124 thr_panic(const char *why)
125 {
126 common_panic("*** libc thread failure: ", why);
127 }
128
129 void
130 aio_panic(const char *why)
131 {
132 common_panic("*** libc aio system failure: ", why);
133 }
134
135 void
136 mutex_panic(mutex_t *mp, const char *why)
137 {
138 panic_mutex = mp;
139 common_panic("*** libc mutex system failure: ", why);
140 }
141
142 /*
143 * Utility function for converting a long integer to a string, avoiding stdio.
144 * 'base' must be one of 10 or 16
145 */
146 void
147 ultos(uint64_t n, int base, char *s)
148 {
149 char lbuf[24]; /* 64 bits fits in 16 hex digits, 20 decimal */
150 char *cp = lbuf;
151
152 do {
153 *cp++ = "0123456789abcdef"[n%base];
154 n /= base;
155 } while (n);
156 if (base == 16) {
157 *s++ = '0';
158 *s++ = 'x';
159 }
160 do {
161 *s++ = *--cp;
162 } while (cp > lbuf);
163 *s = '\0';
164 }
165
166 /*
167 * Report application lock usage error for mutexes and condvars.
168 * Not called if _THREAD_ERROR_DETECTION=0.
169 * Continue execution if _THREAD_ERROR_DETECTION=1.
170 * Dump core if _THREAD_ERROR_DETECTION=2.
171 */
172 void
173 lock_error(const mutex_t *mp, const char *who, void *cv, const char *msg)
174 {
175 mutex_t mcopy;
176 char buf[800];
177 uberdata_t *udp;
178 ulwp_t *self;
179 lwpid_t lwpid;
180 pid_t pid;
181
182 /*
183 * Take a snapshot of the mutex before it changes (we hope!).
184 * Use memcpy() rather than 'mcopy = *mp' in case mp is unaligned.
185 */
186 (void) memcpy(&mcopy, mp, sizeof (mcopy));
187
188 /* avoid recursion deadlock */
189 if ((self = __curthread()) != NULL) {
190 if (assert_thread == self)
191 _exit(127);
192 enter_critical(self);
193 (void) _lwp_mutex_lock(&assert_lock);
194 assert_thread = self;
195 lwpid = self->ul_lwpid;
196 udp = self->ul_uberdata;
197 pid = udp->pid;
198 } else {
199 self = NULL;
200 (void) _lwp_mutex_lock(&assert_lock);
201 lwpid = _lwp_self();
202 udp = &__uberdata;
203 pid = getpid();
204 }
205
206 (void) strcpy(buf,
207 "\n*** _THREAD_ERROR_DETECTION: lock usage error detected ***\n");
208 (void) strcat(buf, who);
209 (void) strcat(buf, "(");
210 if (cv != NULL) {
211 ultos((uint64_t)(uintptr_t)cv, 16, buf + strlen(buf));
212 (void) strcat(buf, ", ");
213 }
214 ultos((uint64_t)(uintptr_t)mp, 16, buf + strlen(buf));
215 (void) strcat(buf, ")");
216 if (msg != NULL) {
217 (void) strcat(buf, ": ");
218 (void) strcat(buf, msg);
219 } else if (!mutex_held(&mcopy)) {
220 (void) strcat(buf, ": calling thread does not own the lock");
221 } else if (mcopy.mutex_rcount) {
222 (void) strcat(buf, ": mutex rcount = ");
223 ultos((uint64_t)mcopy.mutex_rcount, 10, buf + strlen(buf));
224 } else {
225 (void) strcat(buf, ": calling thread already owns the lock");
226 }
227 (void) strcat(buf, "\ncalling thread is ");
228 ultos((uint64_t)(uintptr_t)self, 16, buf + strlen(buf));
229 (void) strcat(buf, " thread-id ");
230 ultos((uint64_t)lwpid, 10, buf + strlen(buf));
231 if (msg != NULL || mutex_held(&mcopy))
232 /* EMPTY */;
233 else if (mcopy.mutex_lockw == 0)
234 (void) strcat(buf, "\nthe lock is unowned");
235 else if (!(mcopy.mutex_type & USYNC_PROCESS)) {
236 (void) strcat(buf, "\nthe lock owner is ");
237 ultos((uint64_t)mcopy.mutex_owner, 16, buf + strlen(buf));
238 } else {
239 (void) strcat(buf, " in process ");
240 ultos((uint64_t)pid, 10, buf + strlen(buf));
241 (void) strcat(buf, "\nthe lock owner is ");
242 ultos((uint64_t)mcopy.mutex_owner, 16, buf + strlen(buf));
243 (void) strcat(buf, " in process ");
244 ultos((uint64_t)mcopy.mutex_ownerpid, 10, buf + strlen(buf));
245 }
246 (void) strcat(buf, "\n\n");
247 (void) __write(2, buf, strlen(buf));
248 if (udp->uberflags.uf_thread_error_detection >= 2)
249 Abort(buf);
250 assert_thread = NULL;
251 (void) _lwp_mutex_unlock(&assert_lock);
252 if (self != NULL)
253 exit_critical(self);
254 }
255
256 /*
257 * Report application lock usage error for rwlocks.
258 * Not called if _THREAD_ERROR_DETECTION=0.
259 * Continue execution if _THREAD_ERROR_DETECTION=1.
260 * Dump core if _THREAD_ERROR_DETECTION=2.
261 */
262 void
263 rwlock_error(const rwlock_t *rp, const char *who, const char *msg)
264 {
265 rwlock_t rcopy;
266 uint32_t rwstate;
267 char buf[800];
268 uberdata_t *udp;
269 ulwp_t *self;
270 lwpid_t lwpid;
271 pid_t pid;
272 int process;
273
274 /*
275 * Take a snapshot of the rwlock before it changes (we hope!).
276 * Use memcpy() rather than 'rcopy = *rp' in case rp is unaligned.
277 */
278 (void) memcpy(&rcopy, rp, sizeof (rcopy));
279
280 /* avoid recursion deadlock */
281 if ((self = __curthread()) != NULL) {
282 if (assert_thread == self)
283 _exit(127);
284 enter_critical(self);
285 (void) _lwp_mutex_lock(&assert_lock);
286 assert_thread = self;
287 lwpid = self->ul_lwpid;
288 udp = self->ul_uberdata;
289 pid = udp->pid;
290 } else {
291 self = NULL;
292 (void) _lwp_mutex_lock(&assert_lock);
293 lwpid = _lwp_self();
294 udp = &__uberdata;
295 pid = getpid();
296 }
297
298 rwstate = (uint32_t)rcopy.rwlock_readers;
299 process = (rcopy.rwlock_type & USYNC_PROCESS);
300
301 (void) strcpy(buf,
302 "\n*** _THREAD_ERROR_DETECTION: lock usage error detected ***\n");
303 (void) strcat(buf, who);
304 (void) strcat(buf, "(");
305 ultos((uint64_t)(uintptr_t)rp, 16, buf + strlen(buf));
306 (void) strcat(buf, "): ");
307 (void) strcat(buf, msg);
308 (void) strcat(buf, "\ncalling thread is ");
309 ultos((uint64_t)(uintptr_t)self, 16, buf + strlen(buf));
310 (void) strcat(buf, " thread-id ");
311 ultos((uint64_t)lwpid, 10, buf + strlen(buf));
312 if (process) {
313 (void) strcat(buf, " in process ");
314 ultos((uint64_t)pid, 10, buf + strlen(buf));
315 }
316 if (rwstate & URW_WRITE_LOCKED) {
317 (void) strcat(buf, "\nthe writer lock owner is ");
318 ultos((uint64_t)rcopy.rwlock_owner, 16,
319 buf + strlen(buf));
320 if (process) {
321 (void) strcat(buf, " in process ");
322 ultos((uint64_t)rcopy.rwlock_ownerpid, 10,
323 buf + strlen(buf));
324 }
325 } else if (rwstate & URW_READERS_MASK) {
326 (void) strcat(buf, "\nthe reader lock is held by ");
327 ultos((uint64_t)(rwstate & URW_READERS_MASK), 10,
328 buf + strlen(buf));
329 (void) strcat(buf, " readers");
330 } else {
331 (void) strcat(buf, "\nthe lock is unowned");
332 }
333 if (rwstate & URW_HAS_WAITERS)
334 (void) strcat(buf, "\nand the lock appears to have waiters");
335 (void) strcat(buf, "\n\n");
336 (void) __write(2, buf, strlen(buf));
337 if (udp->uberflags.uf_thread_error_detection >= 2)
338 Abort(buf);
339 assert_thread = NULL;
340 (void) _lwp_mutex_unlock(&assert_lock);
341 if (self != NULL)
342 exit_critical(self);
343 }
344
345 /*
346 * Report a thread usage error.
347 * Not called if _THREAD_ERROR_DETECTION=0.
348 * Writes message and continues execution if _THREAD_ERROR_DETECTION=1.
349 * Writes message and dumps core if _THREAD_ERROR_DETECTION=2.
350 */
351 void
352 thread_error(const char *msg)
353 {
354 char buf[800];
355 uberdata_t *udp;
356 ulwp_t *self;
357 lwpid_t lwpid;
358
359 /* avoid recursion deadlock */
360 if ((self = __curthread()) != NULL) {
361 if (assert_thread == self)
362 _exit(127);
363 enter_critical(self);
364 (void) _lwp_mutex_lock(&assert_lock);
365 assert_thread = self;
366 lwpid = self->ul_lwpid;
367 udp = self->ul_uberdata;
368 } else {
369 self = NULL;
370 (void) _lwp_mutex_lock(&assert_lock);
371 lwpid = _lwp_self();
372 udp = &__uberdata;
373 }
374
375 (void) strcpy(buf, "\n*** _THREAD_ERROR_DETECTION: "
376 "thread usage error detected ***\n*** ");
377 (void) strcat(buf, msg);
378
379 (void) strcat(buf, "\n*** calling thread is ");
380 ultos((uint64_t)(uintptr_t)self, 16, buf + strlen(buf));
381 (void) strcat(buf, " thread-id ");
382 ultos((uint64_t)lwpid, 10, buf + strlen(buf));
383 (void) strcat(buf, "\n\n");
384 (void) __write(2, buf, strlen(buf));
385 if (udp->uberflags.uf_thread_error_detection >= 2)
386 Abort(buf);
387 assert_thread = NULL;
388 (void) _lwp_mutex_unlock(&assert_lock);
389 if (self != NULL)
390 exit_critical(self);
391 }
392
393 /*
394 * We use __assfail() because the libc __assert() calls
395 * gettext() which calls malloc() which grabs a mutex.
396 * We do everything without calling standard i/o.
397 * assfail() and _assfail() are exported functions;
398 * __assfail() is private to libc.
399 */
400 #pragma weak _assfail = __assfail
401 void
402 __assfail(const char *assertion, const char *filename, int line_num)
403 {
404 char buf[800]; /* no assert() message in the library is this long */
405 ulwp_t *self;
406 lwpid_t lwpid;
407
408 /* avoid recursion deadlock */
409 if ((self = __curthread()) != NULL) {
410 if (assert_thread == self)
411 _exit(127);
412 enter_critical(self);
413 (void) _lwp_mutex_lock(&assert_lock);
414 assert_thread = self;
415 lwpid = self->ul_lwpid;
416 } else {
417 self = NULL;
418 (void) _lwp_mutex_lock(&assert_lock);
419 lwpid = _lwp_self();
420 }
421
422 /*
423 * This is a hack, but since the Abort function isn't exported
424 * to outside consumers, libzpool's vpanic() function calls
425 * assfail() with a filename set to NULL. In that case, it'd be
426 * best not to print "assertion failed" since it was a panic and
427 * not an assertion failure.
428 */
429 if (filename == NULL) {
430 (void) strcpy(buf, "failure for thread ");
431 } else {
432 (void) strcpy(buf, "assertion failed for thread ");
433 }
434
435 ultos((uint64_t)(uintptr_t)self, 16, buf + strlen(buf));
436 (void) strcat(buf, ", thread-id ");
437 ultos((uint64_t)lwpid, 10, buf + strlen(buf));
438 (void) strcat(buf, ": ");
439 (void) strcat(buf, assertion);
440
441 if (filename != NULL) {
442 (void) strcat(buf, ", file ");
443 (void) strcat(buf, filename);
444 (void) strcat(buf, ", line ");
445 ultos((uint64_t)line_num, 10, buf + strlen(buf));
446 }
447
448 (void) strcat(buf, "\n");
449 (void) __write(2, buf, strlen(buf));
450 /*
451 * We could replace the call to Abort() with the following code
452 * if we want just to issue a warning message and not die.
453 * assert_thread = NULL;
454 * _lwp_mutex_unlock(&assert_lock);
455 * if (self != NULL)
456 * exit_critical(self);
457 */
458 Abort(buf);
459 }
460
461 /*
462 * We define and export this version of assfail() just because libaio
463 * used to define and export it, needlessly. Now that libaio is folded
464 * into libc, we need to continue this for ABI/version reasons.
465 * We don't use "#pragma weak assfail __assfail" in order to avoid
466 * warnings from the check_fnames utility at build time for libraries
467 * that define their own version of assfail().
468 */
469 void
470 assfail(const char *assertion, const char *filename, int line_num)
471 {
472 __assfail(assertion, filename, line_num);
473 }
474
475 void
476 assfail3(const char *assertion, uintmax_t lv, const char *op, uintmax_t rv,
477 const char *filename, int line_num)
478 {
479 char buf[1000];
480 (void) strcpy(buf, assertion);
481 (void) strcat(buf, " (");
482 ultos((uint64_t)lv, 16, buf + strlen(buf));
483 (void) strcat(buf, " ");
484 (void) strcat(buf, op);
485 (void) strcat(buf, " ");
486 ultos((uint64_t)rv, 16, buf + strlen(buf));
487 (void) strcat(buf, ")");
488 __assfail(buf, filename, line_num);
489 }