contrib/libexecinfo/backtrace.c

   1 /*      $NetBSD: backtrace.c,v 1.3 2013/08/29 14:58:56 christos Exp $   */
   2
   3 /*-
   4  * Copyright (c) 2012 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Christos Zoulas.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31 #include <sys/cdefs.h>
  32 __RCSID("$NetBSD: backtrace.c,v 1.3 2013/08/29 14:58:56 christos Exp $");
  33
  34 #include <sys/param.h>
  35 #include <assert.h>
  36 #define _WITH_DPRINTF
  37 #include <stdio.h>
  38 #include <string.h>
  39 #include <stdlib.h>
  40 #include <stdarg.h>
  41 #include <stdint.h>
  42 #include <stddef.h>
  43 #include <unistd.h>
  44 #include <fcntl.h>
  45 #include <dlfcn.h>
  46 #include <elf.h>
  47
  48 #include "execinfo.h"
  49 #include "symtab.h"
  50
  51 #ifdef __linux__
  52 #define SELF    "/proc/self/exe"
  53 #else
  54 #include <sys/sysctl.h>
  55 #define SELF    "/proc/curproc/file"
  56 #endif
  57
  58 static int
  59 open_self(int flags)
  60 {
  61         const char *pathname = SELF;
  62 #ifdef KERN_PROC_PATHNAME
  63         static const int name[] = {
  64                 CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1,
  65         };
  66         char path[MAXPATHLEN];
  67         size_t len;
  68
  69         len = sizeof(path);
  70         if (sysctl(name, 4, path, &len, NULL, 0) != -1)
  71                 pathname = path;
  72 #endif
  73         return open(pathname, flags);
  74 }
  75
  76
  77 static int __printflike(4, 5)
  78 rasprintf(char **buf, size_t *bufsiz, size_t offs, const char *fmt, ...)
  79 {
  80         for (;;) {
  81                 size_t nbufsiz;
  82                 char *nbuf;
  83
  84                 if (*buf && offs < *bufsiz) {
  85                         va_list ap;
  86                         int len;
  87
  88                         va_start(ap, fmt);
  89                         len = vsnprintf(*buf + offs, *bufsiz - offs, fmt, ap);
  90                         va_end(ap);
  91
  92                         if (len < 0 || (size_t)len + 1 < *bufsiz - offs)
  93                                 return len;
  94                         nbufsiz = MAX(*bufsiz + 512, (size_t)len + 1);
  95                 } else
  96                         nbufsiz = MAX(offs, *bufsiz) + 512;
  97
  98                 nbuf = realloc(*buf, nbufsiz);
  99                 if (nbuf == NULL)
 100                         return -1;
 101                 *buf = nbuf;
 102                 *bufsiz = nbufsiz;
 103         }
 104 }
 105
 106 /*
 107  * format specifiers:
 108  *      %a      = address
 109  *      %n      = symbol_name
 110  *      %d      = symbol_address - address
 111  *      %D      = if symbol_address == address "" else +%d
 112  *      %f      = filename
 113  */
 114 static ssize_t
 115 format_string(char **buf, size_t *bufsiz, size_t offs, const char *fmt,
 116     Dl_info *dli, const void *addr)
 117 {
 118         ptrdiff_t diff = (const char *)addr - (const char *)dli->dli_saddr;
 119         size_t o = offs;
 120         int len;
 121
 122         for (; *fmt; fmt++) {
 123                 if (*fmt != '%')
 124                         goto printone;
 125                 switch (*++fmt) {
 126                 case 'a':
 127                         len = rasprintf(buf, bufsiz, o, "%p", addr);
 128                         break;
 129                 case 'n':
 130                         len = rasprintf(buf, bufsiz, o, "%s", dli->dli_sname);
 131                         break;
 132                 case 'D':
 133                         if (diff)
 134                                 len = rasprintf(buf, bufsiz, o, "+0x%tx", diff);
 135                         else
 136                                 len = 0;
 137                         break;
 138                 case 'd':
 139                         len = rasprintf(buf, bufsiz, o, "0x%tx", diff);
 140                         break;
 141                 case 'f':
 142                         len = rasprintf(buf, bufsiz, o, "%s", dli->dli_fname);
 143                         break;
 144                 default:
 145                 printone:
 146                         len = rasprintf(buf, bufsiz, o, "%c", *fmt);
 147                         break;
 148                 }
 149                 if (len == -1)
 150                         return -1;
 151                 o += len;
 152         }
 153         return o - offs;
 154 }
 155
 156 static ssize_t
 157 format_address(symtab_t *st, char **buf, size_t *bufsiz, size_t offs,
 158     const char *fmt, const void *addr)
 159 {
 160         Dl_info dli;
 161
 162         memset(&dli, 0, sizeof(dli));
 163         (void)dladdr(addr, &dli);
 164         if (st)
 165                 symtab_find(st, addr, &dli);
 166
 167         if (dli.dli_sname == NULL)
 168                 dli.dli_sname = "???";
 169         if (dli.dli_fname == NULL)
 170                 dli.dli_fname = "???";
 171         if (dli.dli_saddr == NULL)
 172                 dli.dli_saddr = (void *)(intptr_t)addr;
 173
 174         return format_string(buf, bufsiz, offs, fmt, &dli, addr);
 175 }
 176
 177 char **
 178 backtrace_symbols_fmt(void *const *trace, size_t len, const char *fmt)
 179 {
 180
 181         static const size_t slen = sizeof(char *) + 64; /* estimate */
 182         char *ptr;
 183         symtab_t *st;
 184         int fd;
 185
 186         if ((fd = open_self(O_RDONLY)) != -1)
 187                 st = symtab_create(fd, -1, STT_FUNC);
 188         else
 189                 st = NULL;
 190
 191         if ((ptr = calloc(len, slen)) == NULL)
 192                 goto out;
 193
 194         size_t psize = len * slen;
 195         size_t offs = len * sizeof(char *);
 196
 197         /* We store only offsets in the first pass because of realloc */
 198         for (size_t i = 0; i < len; i++) {
 199                 ssize_t x;
 200                 ((char **)(void *)ptr)[i] = (void *)offs;
 201                 x = format_address(st, &ptr, &psize, offs, fmt, trace[i]);
 202                 if (x == -1) {
 203                         free(ptr);
 204                         ptr = NULL;
 205                         goto out;
 206                 }
 207                 offs += x;
 208                 ptr[offs++] = '\0';
 209                 assert(offs < psize);
 210         }
 211
 212         /* Change offsets to pointers */
 213         for (size_t j = 0; j < len; j++)
 214                 ((char **)(void *)ptr)[j] += (intptr_t)ptr;
 215
 216 out:
 217         symtab_destroy(st);
 218         if (fd != -1)
 219                 (void)close(fd);
 220
 221         return (void *)ptr;
 222 }
 223
 224 int
 225 backtrace_symbols_fd_fmt(void *const *trace, size_t len, int fd,
 226     const char *fmt)
 227 {
 228         char **s = backtrace_symbols_fmt(trace, len, fmt);
 229         if (s == NULL)
 230                 return -1;
 231         for (size_t i = 0; i < len; i++)
 232                 if (dprintf(fd, "%s\n", s[i]) < 0)
 233                         break;
 234         free(s);
 235         return 0;
 236 }
 237
 238 static const char fmt[] = "%a <%n%D> at %f";
 239
 240 char **
 241 backtrace_symbols(void *const *trace, size_t len)
 242 {
 243         return backtrace_symbols_fmt(trace, len, fmt);
 244 }
 245
 246 int
 247 backtrace_symbols_fd(void *const *trace, size_t len, int fd)
 248 {
 249         return backtrace_symbols_fd_fmt(trace, len, fd, fmt);
 250 }