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  * 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 }