libbacktrace/fileline.c

   1 /* fileline.c -- Get file and line number information in a backtrace.
   2    Copyright (C) 2012 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor, Google.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions are
   7 met:
   8
   9     (1) Redistributions of source code must retain the above copyright
  10     notice, this list of conditions and the following disclaimer.
  11
  12     (2) Redistributions in binary form must reproduce the above copyright
  13     notice, this list of conditions and the following disclaimer in
  14     the documentation and/or other materials provided with the
  15     distribution.
  16
  17     (3) The name of the author may not be used to
  18     endorse or promote products derived from this software without
  19     specific prior written permission.
  20
  21 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  23 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  24 DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  25 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  27 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  29 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  30 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31 POSSIBILITY OF SUCH DAMAGE.  */
  32
  33 #include "config.h"
  34
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <errno.h>
  38 #include <fcntl.h>
  39 #include <stdlib.h>
  40
  41 #include "backtrace.h"
  42 #include "internal.h"
  43
  44 #ifndef HAVE_GETEXECNAME
  45 #define getexecname() NULL
  46 #endif
  47
  48 /* Initialize the fileline information from the executable.  Returns 1
  49    on success, 0 on failure.  */
  50
  51 static int
  52 fileline_initialize (struct backtrace_state *state,
  53                      backtrace_error_callback error_callback, void *data)
  54 {
  55   int failed;
  56   fileline fileline_fn;
  57   int pass;
  58   int called_error_callback;
  59   int descriptor;
  60
  61   failed = state->fileline_initialization_failed;
  62
  63   if (state->threaded)
  64     {
  65       /* Use __sync_bool_compare_and_swap to do an atomic load.  */
  66       while (!__sync_bool_compare_and_swap
  67              (&state->fileline_initialization_failed, failed, failed))
  68         failed = state->fileline_initialization_failed;
  69     }
  70
  71   if (failed)
  72     {
  73       error_callback (data, "failed to read executable information", -1);
  74       return 0;
  75     }
  76
  77   fileline_fn = state->fileline_fn;
  78   if (state->threaded)
  79     {
  80       while (!__sync_bool_compare_and_swap (&state->fileline_fn, fileline_fn,
  81                                             fileline_fn))
  82         fileline_fn = state->fileline_fn;
  83     }
  84   if (fileline_fn != NULL)
  85     return 1;
  86
  87   /* We have not initialized the information.  Do it now.  */
  88
  89   descriptor = -1;
  90   called_error_callback = 0;
  91   for (pass = 0; pass < 4; ++pass)
  92     {
  93       const char *filename;
  94       int does_not_exist;
  95
  96       switch (pass)
  97         {
  98         case 0:
  99           filename = state->filename;
 100           break;
 101         case 1:
 102           filename = getexecname ();
 103           break;
 104         case 2:
 105           filename = "/proc/self/exe";
 106           break;
 107         case 3:
 108           filename = "/proc/curproc/file";
 109           break;
 110         default:
 111           abort ();
 112         }
 113
 114       if (filename == NULL)
 115         continue;
 116
 117       descriptor = backtrace_open (filename, error_callback, data,
 118                                    &does_not_exist);
 119       if (descriptor < 0 && !does_not_exist)
 120         {
 121           called_error_callback = 1;
 122           break;
 123         }
 124       if (descriptor >= 0)
 125         break;
 126     }
 127
 128   if (descriptor < 0)
 129     {
 130       if (!called_error_callback)
 131         {
 132           if (state->filename != NULL)
 133             error_callback (data, state->filename, ENOENT);
 134           else
 135             error_callback (data,
 136                             "libbacktrace could not find executable to open",
 137                             0);
 138         }
 139       failed = 1;
 140     }
 141
 142   if (!failed)
 143     {
 144       if (!backtrace_initialize (state, descriptor, error_callback, data,
 145                                  &fileline_fn))
 146         failed = 1;
 147     }
 148
 149   if (failed)
 150     {
 151       if (!state->threaded)
 152         state->fileline_initialization_failed = 1;
 153       else
 154         __sync_bool_compare_and_swap (&state->fileline_initialization_failed,
 155                                       0, failed);
 156       return 0;
 157     }
 158
 159   if (!state->threaded)
 160     state->fileline_fn = fileline_fn;
 161   else
 162     {
 163       __sync_bool_compare_and_swap (&state->fileline_fn, NULL, fileline_fn);
 164
 165       /* At this point we know that state->fileline_fn is not NULL.
 166          Either we stored our value, or some other thread stored its
 167          value.  If some other thread stored its value, we leak the
 168          one we just initialized.  Either way, state->fileline_fn is
 169          initialized.  The compare_and_swap is a full memory barrier,
 170          so we should have full access to that value even if it was
 171          created by another thread.  */
 172     }
 173
 174   return 1;
 175 }
 176
 177 /* Given a PC, find the file name, line number, and function name.  */
 178
 179 int
 180 backtrace_pcinfo (struct backtrace_state *state, uintptr_t pc,
 181                   backtrace_full_callback callback,
 182                   backtrace_error_callback error_callback, void *data)
 183 {
 184   if (!fileline_initialize (state, error_callback, data))
 185     return 0;
 186
 187   if (state->fileline_initialization_failed)
 188     return 0;
 189
 190   return state->fileline_fn (state, pc, callback, error_callback, data);
 191 }
 192
 193 /* Given a PC, find the symbol for it, and its value.  */
 194
 195 int
 196 backtrace_syminfo (struct backtrace_state *state, uintptr_t pc,
 197                    backtrace_syminfo_callback callback,
 198                    backtrace_error_callback error_callback, void *data)
 199 {
 200   if (!fileline_initialize (state, error_callback, data))
 201     return 0;
 202
 203   if (state->fileline_initialization_failed)
 204     return 0;
 205
 206   state->syminfo_fn (state, pc, callback, error_callback, data);
 207   return 1;
 208 }