usr/src/lib/libc/port/threads/assfail.c

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