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 2011 Nexenta Systems, Inc.  All rights reserved.
  24  */
  25 /*
  26  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  27  * Use is subject to license terms.
  28  */
  29 
  30 #pragma weak __fex_get_log = fex_get_log
  31 #pragma weak __fex_set_log = fex_set_log
  32 #pragma weak __fex_get_log_depth = fex_get_log_depth
  33 #pragma weak __fex_set_log_depth = fex_set_log_depth
  34 #pragma weak __fex_log_entry = fex_log_entry
  35 
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <unistd.h>
  39 #include <string.h>
  40 #include <signal.h>
  41 #include <ucontext.h>
  42 #include <sys/frame.h>
  43 #include <fenv.h>
  44 #include <sys/ieeefp.h>
  45 #include <thread.h>
  46 #include "fex_handler.h"
  47 
  48 #if !defined(PC)
  49 #if defined(REG_PC)
  50 #define PC      REG_PC
  51 #else
  52 #error Neither PC nor REG_PC is defined!
  53 #endif
  54 #endif
  55 
  56 static FILE *log_fp = NULL;
  57 static mutex_t log_lock = DEFAULTMUTEX;
  58 static int log_depth = 100;
  59 
  60 FILE *fex_get_log(void)
  61 {
  62         FILE    *fp;
  63 
  64         mutex_lock(&log_lock);
  65         fp = log_fp;
  66         mutex_unlock(&log_lock);
  67         return fp;
  68 }
  69 
  70 int fex_set_log(FILE *fp)
  71 {
  72         mutex_lock(&log_lock);
  73         log_fp = fp;
  74         mutex_unlock(&log_lock);
  75         __fex_update_te();
  76         return 1;
  77 }
  78 
  79 int fex_get_log_depth(void)
  80 {
  81         int     d;
  82 
  83         mutex_lock(&log_lock);
  84         d = log_depth;
  85         mutex_unlock(&log_lock);
  86         return d;
  87 }
  88 
  89 int fex_set_log_depth(int d)
  90 {
  91         if (d < 0)
  92                 return 0;
  93         mutex_lock(&log_lock);
  94         log_depth = d;
  95         mutex_unlock(&log_lock);
  96         return 1;
  97 }
  98 
  99 static struct exc_list {
 100         struct exc_list         *next;
 101         char                    *addr;
 102         unsigned long           code;
 103         int                     nstack;
 104         char                    *stack[1]; /* actual length is max(1,nstack) */
 105 } *list = NULL;
 106 
 107 #ifdef __sparcv9
 108 #define FRAMEP(X)       (struct frame *)((char*)(X)+(((long)(X)&1)?2047:0))
 109 #else
 110 #define FRAMEP(X)       (struct frame *)(X)
 111 #endif
 112 
 113 #ifdef _LP64
 114 #define PDIG            "16"
 115 #else
 116 #define PDIG            "8"
 117 #endif
 118 
 119 /* look for a matching exc_list; return 1 if one is found,
 120    otherwise add this one to the list and return 0 */
 121 static int check_exc_list(char *addr, unsigned long code, char *stk,
 122     struct frame *fp)
 123 {
 124         struct exc_list *l, *ll = NULL;
 125         struct frame    *f;
 126         int             i, n;
 127 
 128         if (list) {
 129                 for (l = list; l; ll = l, l = l->next) {
 130                         if (l->addr != addr || l->code != code)
 131                                 continue;
 132                         if (log_depth < 1 || l->nstack < 1)
 133                                 return 1;
 134                         if (l->stack[0] != stk)
 135                                 continue;
 136                         n = 1;
 137                         for (i = 1, f = fp; i < log_depth && i < l->nstack &&
 138                             f && f->fr_savpc; i++, f = FRAMEP(f->fr_savfp))
 139                                 if (l->stack[i] != (char *)f->fr_savpc) {
 140                                         n = 0;
 141                                         break;
 142                                 }
 143                         if (n)
 144                                 return 1;
 145                 }
 146         }
 147 
 148         /* create a new exc_list structure and tack it on the list */
 149         for (n = 1, f = fp; n < log_depth && f && f->fr_savpc;
 150             n++, f = FRAMEP(f->fr_savfp)) ;
 151         if ((l = (struct exc_list *)malloc(sizeof(struct exc_list) +
 152             (n - 1) * sizeof(char *))) != NULL) {
 153                 l->next = NULL;
 154                 l->addr = addr;
 155                 l->code = code;
 156                 l->nstack = ((log_depth < 1)? 0 : n);
 157                 l->stack[0] = stk;
 158                 for (i = 1; i < n; i++) {
 159                         l->stack[i] = (char *)fp->fr_savpc;
 160                         fp = FRAMEP(fp->fr_savfp);
 161                 }
 162                 if (list)
 163                         ll->next = l;
 164                 else
 165                         list = l;
 166         }
 167         return 0;
 168 }
 169 
 170 /*
 171 * Warning: cleverness ahead
 172 *
 173 * In the following code, the use of sprintf+write rather than fprintf
 174 * to send output to the log file is intentional.  The reason is that
 175 * fprintf is not async-signal-safe.  "But," you protest, "SIGFPE is
 176 * not an asynchronous signal!  It's always handled by the same thread
 177 * that executed the fpop that provoked it."  That's true, but a prob-
 178 * lem arises because (i) base conversion in fprintf can cause a fp
 179 * exception and (ii) my signal handler acquires a mutex lock before
 180 * sending output to the log file (so that outputs for entries from
 181 * different threads aren't interspersed).  Therefore, if the code
 182 * were to use fprintf, a deadlock could occur as follows:
 183 *
 184 *       Thread A                        Thread B
 185 *
 186 *       Incurs a fp exception,          Calls fprintf,
 187 *       acquires log_lock               acquires file rmutex lock
 188 *
 189 *       Calls fprintf,                  Incurs a fp exception,
 190 *       waits for file rmutex lock      waits for log_lock
 191 *
 192 * (I could just verify that fprintf doesn't hold the rmutex lock while
 193 * it's doing the base conversion, but since efficiency is of little
 194 * concern here, I opted for the safe and dumb route.)
 195 */
 196 
 197 static void print_stack(int fd, char *addr, struct frame *fp)
 198 {
 199         int     i;
 200         char    *name, buf[30];
 201 
 202         for (i = 0; i < log_depth && addr != NULL; i++) {
 203                 if (__fex_sym(addr, &name) != NULL) {
 204                         write(fd, buf, sprintf(buf, "  0x%0" PDIG "lx  ",
 205                             (long)addr));
 206                         write(fd, name, strlen(name));
 207                         write(fd, "\n", 1);
 208                         if (!strcmp(name, "main"))
 209                                 break;
 210                 } else {
 211                         write(fd, buf, sprintf(buf, "  0x%0" PDIG "lx\n",
 212                             (long)addr));
 213                 }
 214                 if (fp == NULL)
 215                         break;
 216                 addr = (char *)fp->fr_savpc;
 217                 fp = FRAMEP(fp->fr_savfp);
 218         }
 219 }
 220 
 221 void fex_log_entry(const char *msg)
 222 {
 223         ucontext_t      uc;
 224         struct frame    *fp;
 225         char            *stk;
 226         int             fd;
 227 
 228         /* if logging is disabled, just return */
 229         mutex_lock(&log_lock);
 230         if (log_fp == NULL) {
 231                 mutex_unlock(&log_lock);
 232                 return;
 233         }
 234 
 235         /* get the frame pointer from the current context and
 236            pop our own frame */
 237         getcontext(&uc);
 238 #if defined(__sparc) || defined(__amd64)
 239         fp = FRAMEP(uc.uc_mcontext.gregs[REG_SP]);
 240 #elif defined(__i386)   /* !defined(__amd64) */
 241         fp = FRAMEP(uc.uc_mcontext.gregs[EBP]);
 242 #else
 243 #error Unknown architecture
 244 #endif
 245         if (fp == NULL) {
 246                 mutex_unlock(&log_lock);
 247                 return;
 248         }
 249         stk = (char *)fp->fr_savpc;
 250         fp = FRAMEP(fp->fr_savfp);
 251 
 252         /* if we've already logged this message here, don't make an entry */
 253         if (check_exc_list(stk, (unsigned long)msg, stk, fp)) {
 254                 mutex_unlock(&log_lock);
 255                 return;
 256         }
 257 
 258         /* make an entry */
 259         fd = fileno(log_fp);
 260         write(fd, "fex_log_entry: ", 15);
 261         write(fd, msg, strlen(msg));
 262         write(fd, "\n", 1);
 263         __fex_sym_init();
 264         print_stack(fd, stk, fp);
 265         mutex_unlock(&log_lock);
 266 }
 267 
 268 static const char *exception[FEX_NUM_EXC] = {
 269         "inexact result",
 270         "division by zero",
 271         "underflow",
 272         "overflow",
 273         "invalid operation (0/0)",
 274         "invalid operation (inf/inf)",
 275         "invalid operation (inf-inf)",
 276         "invalid operation (0*inf)",
 277         "invalid operation (sqrt)",
 278         "invalid operation (snan)",
 279         "invalid operation (int)",
 280         "invalid operation (cmp)"
 281 };
 282 
 283 void
 284 __fex_mklog(ucontext_t *uap, char *addr, int f, enum fex_exception e,
 285     int m, void *p)
 286 {
 287         struct  frame   *fp;
 288         char            *stk, *name, buf[30];
 289         int             fd;
 290 
 291         /* if logging is disabled, just return */
 292         mutex_lock(&log_lock);
 293         if (log_fp == NULL) {
 294                 mutex_unlock(&log_lock);
 295                 return;
 296         }
 297 
 298         /* get stack info */
 299 #if defined(__sparc)
 300         stk = (char*)uap->uc_mcontext.gregs[REG_PC];
 301         fp = FRAMEP(uap->uc_mcontext.gregs[REG_SP]);
 302 #elif defined(__amd64)
 303         stk = (char*)uap->uc_mcontext.gregs[REG_PC];
 304         fp = FRAMEP(uap->uc_mcontext.gregs[REG_RBP]);
 305 #elif defined(__i386)   /* !defined(__amd64) */
 306         stk = (char*)uap->uc_mcontext.gregs[PC];
 307         fp = FRAMEP(uap->uc_mcontext.gregs[EBP]);
 308 #else
 309 #error Unknown architecture
 310 #endif
 311 
 312         /* if the handling mode is the default and this exception's
 313            flag is already raised, don't make an entry */
 314         if (m == FEX_NONSTOP) {
 315                 switch (e) {
 316                 case fex_inexact:
 317                         if (f & FE_INEXACT) {
 318                                 mutex_unlock(&log_lock);
 319                                 return;
 320                         }
 321                         break;
 322                 case fex_underflow:
 323                         if (f & FE_UNDERFLOW) {
 324                                 mutex_unlock(&log_lock);
 325                                 return;
 326                         }
 327                         break;
 328                 case fex_overflow:
 329                         if (f & FE_OVERFLOW) {
 330                                 mutex_unlock(&log_lock);
 331                                 return;
 332                         }
 333                         break;
 334                 case fex_division:
 335                         if (f & FE_DIVBYZERO) {
 336                                 mutex_unlock(&log_lock);
 337                                 return;
 338                         }
 339                         break;
 340                 default:
 341                         if (f & FE_INVALID) {
 342                                 mutex_unlock(&log_lock);
 343                                 return;
 344                         }
 345                         break;
 346                 }
 347         }
 348 
 349         /* if we've already logged this exception at this address,
 350            don't make an entry */
 351         if (check_exc_list(addr, (unsigned long)e, stk, fp)) {
 352                 mutex_unlock(&log_lock);
 353                 return;
 354         }
 355 
 356         /* make an entry */
 357         fd = fileno(log_fp);
 358         write(fd, "Floating point ", 15);
 359         write(fd, exception[e], strlen(exception[e]));
 360         write(fd, buf, sprintf(buf, " at 0x%0" PDIG "lx", (long)addr));
 361         __fex_sym_init();
 362         if (__fex_sym(addr, &name) != NULL) {
 363                 write(fd, " ", 1);
 364                 write(fd, name, strlen(name));
 365         }
 366         switch (m) {
 367         case FEX_NONSTOP:
 368                 write(fd, ", nonstop mode\n", 15);
 369                 break;
 370 
 371         case FEX_ABORT:
 372                 write(fd, ", abort\n", 8);
 373                 break;
 374 
 375         case FEX_NOHANDLER:
 376                 if (p == (void *)SIG_DFL) {
 377                         write(fd, ", handler: SIG_DFL\n", 19);
 378                         break;
 379                 }
 380                 else if (p == (void *)SIG_IGN) {
 381                         write(fd, ", handler: SIG_IGN\n", 19);
 382                         break;
 383                 }
 384                 /* fall through*/
 385         default:
 386                 write(fd, ", handler: ", 11);
 387                 if (__fex_sym((char *)p, &name) != NULL) {
 388                         write(fd, name, strlen(name));
 389                         write(fd, "\n", 1);
 390                 } else {
 391                         write(fd, buf, sprintf(buf, "0x%0" PDIG "lx\n",
 392                             (long)p));
 393                 }
 394                 break;
 395         }
 396         print_stack(fd, stk, fp);
 397         mutex_unlock(&log_lock);
 398 }