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