git.cworth.org Git - apitrace/blob - common/os_posix.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2010-2011 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  *
  24  **************************************************************************/
  25
  26
  27 #include <assert.h>
  28 #include <string.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31
  32 #include <unistd.h>
  33 #include <sys/wait.h>
  34 #include <sys/stat.h>
  35 #include <fcntl.h>
  36 #include <signal.h>
  37
  38 #if defined(__linux__)
  39 #include <linux/limits.h> // PATH_MAX
  40 #endif
  41
  42 #ifdef __APPLE__
  43 #include <sys/syslimits.h> // PATH_MAX
  44 #include <mach-o/dyld.h>
  45 #endif
  46
  47 #ifdef ANDROID
  48 #include <android/log.h>
  49 #endif
  50
  51 #ifndef PATH_MAX
  52 #warning PATH_MAX undefined
  53 #define PATH_MAX 4096
  54 #endif
  55
  56 #include "os.hpp"
  57 #include "os_string.hpp"
  58
  59
  60 namespace os {
  61
  62
  63 String
  64 getProcessName(void)
  65 {
  66     String path;
  67     size_t size = PATH_MAX;
  68     char *buf = path.buf(size);
  69
  70     // http://stackoverflow.com/questions/1023306/finding-current-executables-path-without-proc-self-exe
  71 #ifdef __APPLE__
  72     uint32_t len = size;
  73     if (_NSGetExecutablePath(buf, &len) != 0) {
  74         *buf = 0;
  75         return path;
  76     }
  77     len = strlen(buf);
  78 #else
  79     ssize_t len;
  80     len = readlink("/proc/self/exe", buf, size - 1);
  81     if (len == -1) {
  82         // /proc/self/exe is not available on setuid processes, so fallback to
  83         // /proc/self/cmdline.
  84         int fd = open("/proc/self/cmdline", O_RDONLY);
  85         if (fd >= 0) {
  86             len = read(fd, buf, size - 1);
  87             close(fd);
  88         }
  89     }
  90     if (len <= 0) {
  91         snprintf(buf, size, "%i", (int)getpid());
  92         return path;
  93     }
  94 #endif
  95     path.truncate(len);
  96
  97     return path;
  98 }
  99
 100 String
 101 getCurrentDir(void)
 102 {
 103     String path;
 104     size_t size = PATH_MAX;
 105     char *buf = path.buf(size);
 106
 107     getcwd(buf, size);
 108     buf[size - 1] = 0;
 109
 110     path.truncate();
 111     return path;
 112 }
 113
 114 bool
 115 String::exists(void) const
 116 {
 117     struct stat st;
 118     int err;
 119
 120     err = stat(str(), &st);
 121     if (err) {
 122         return false;
 123     }
 124
 125     if (!S_ISREG(st.st_mode))
 126         return false;
 127
 128     return true;
 129 }
 130
 131 int execute(char * const * args)
 132 {
 133     pid_t pid = fork();
 134     if (pid == 0) {
 135         // child
 136         execvp(args[0], args);
 137         fprintf(stderr, "error: failed to execute %s\n", args[0]);
 138         exit(-1);
 139     } else {
 140         // parent
 141         if (pid == -1) {
 142             fprintf(stderr, "error: failed to fork\n");
 143             return -1;
 144         }
 145         int status = -1;
 146         int ret;
 147         waitpid(pid, &status, 0);
 148         if (WIFEXITED(status)) {
 149             ret = WEXITSTATUS(status);
 150         } else if (WIFSIGNALED(status)) {
 151             // match shell return code
 152             ret = WTERMSIG(status) + 128;
 153         } else {
 154             ret = 128;
 155         }
 156         return ret;
 157     }
 158 }
 159
 160 static volatile bool logging = false;
 161
 162 void
 163 log(const char *format, ...)
 164 {
 165     logging = true;
 166     va_list ap;
 167     va_start(ap, format);
 168     fflush(stdout);
 169 #ifdef ANDROID
 170     __android_log_vprint(ANDROID_LOG_DEBUG, "apitrace", format, ap);
 171 #else
 172     vfprintf(stderr, format, ap);
 173 #endif
 174     va_end(ap);
 175     logging = false;
 176 }
 177
 178 #if defined(__APPLE__)
 179 long long timeFrequency = 0LL;
 180 #endif
 181
 182 void
 183 abort(void)
 184 {
 185     exit(0);
 186 }
 187
 188
 189 static void (*gCallback)(void) = NULL;
 190
 191 #define NUM_SIGNALS 16
 192
 193 struct sigaction old_actions[NUM_SIGNALS];
 194
 195
 196 /*
 197  * See also:
 198  * - http://sourceware.org/git/?p=glibc.git;a=blob;f=debug/segfault.c
 199  * - http://ggi.cvs.sourceforge.net/viewvc/ggi/ggi-core/libgg/gg/cleanup.c?view=markup
 200  */
 201 static void
 202 signalHandler(int sig, siginfo_t *info, void *context)
 203 {
 204     /*
 205      * There are several signals that can happen when logging to stdout/stderr.
 206      * For example, SIGPIPE will be emitted if stderr is a pipe with no
 207      * readers.  Therefore ignore any signal while logging by returning
 208      * immediately, to prevent deadlocks.
 209      */
 210     if (logging) {
 211         return;
 212     }
 213
 214     static int recursion_count = 0;
 215
 216     log("apitrace: warning: caught signal %i\n", sig);
 217
 218     if (recursion_count) {
 219         log("apitrace: warning: recursion handling signal %i\n", sig);
 220     } else {
 221         if (gCallback) {
 222             ++recursion_count;
 223             gCallback();
 224             --recursion_count;
 225         }
 226     }
 227
 228     struct sigaction *old_action;
 229     if (sig >= NUM_SIGNALS) {
 230         /* This should never happen */
 231         log("error: unexpected signal %i\n", sig);
 232         raise(SIGKILL);
 233     }
 234     old_action = &old_actions[sig];
 235
 236     if (old_action->sa_flags & SA_SIGINFO) {
 237         // Handler is in sa_sigaction
 238         old_action->sa_sigaction(sig, info, context);
 239     } else {
 240         if (old_action->sa_handler == SIG_DFL) {
 241             log("apitrace: info: taking default action for signal %i\n", sig);
 242
 243 #if 1
 244             struct sigaction dfl_action;
 245             dfl_action.sa_handler = SIG_DFL;
 246             sigemptyset (&dfl_action.sa_mask);
 247             dfl_action.sa_flags = 0;
 248             sigaction(sig, &dfl_action, NULL);
 249
 250             raise(sig);
 251 #else
 252             raise(SIGKILL);
 253 #endif
 254         } else if (old_action->sa_handler == SIG_IGN) {
 255             /* ignore */
 256         } else {
 257             /* dispatch to handler */
 258             old_action->sa_handler(sig);
 259         }
 260     }
 261 }
 262
 263 void
 264 setExceptionCallback(void (*callback)(void))
 265 {
 266     assert(!gCallback);
 267     if (!gCallback) {
 268         gCallback = callback;
 269
 270         struct sigaction new_action;
 271         new_action.sa_sigaction = signalHandler;
 272         sigemptyset(&new_action.sa_mask);
 273         new_action.sa_flags = SA_SIGINFO | SA_RESTART;
 274
 275
 276         for (int sig = 1; sig < NUM_SIGNALS; ++sig) {
 277             // SIGKILL and SIGSTOP can't be handled.
 278             if (sig == SIGKILL || sig == SIGSTOP) {
 279                 continue;
 280             }
 281
 282             /*
 283              * SIGPIPE can be emitted when writing to stderr that is redirected
 284              * to a pipe without readers.  It is also very unlikely to ocurr
 285              * inside graphics APIs, and most applications where it can occur
 286              * normally already ignore it.  In summary, it is unlikely that a
 287              * SIGPIPE will cause abnormal termination, which it is likely that
 288              * intercepting here will cause problems, so simple don't intercept
 289              * it here.
 290              */
 291             if (sig == SIGPIPE) {
 292                 continue;
 293             }
 294
 295             if (sigaction(sig,  NULL, &old_actions[sig]) >= 0) {
 296                 sigaction(sig,  &new_action, NULL);
 297             }
 298         }
 299     }
 300 }
 301
 302 void
 303 resetExceptionCallback(void)
 304 {
 305     gCallback = NULL;
 306 }
 307
 308 } /* namespace os */
 309