X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=common%2Fos_posix.cpp;h=0d93b31bcafa6e56604fa639a7656d20128835ca;hb=23354536051650b7a8a713e824946d48a7734534;hp=78fefee52e949893e742a3a205b444eedbeb115b;hpb=7257d46c8a6938428750e9272dfb4ac47b9b4404;p=apitrace diff --git a/common/os_posix.cpp b/common/os_posix.cpp index 78fefee..0d93b31 100644 --- a/common/os_posix.cpp +++ b/common/os_posix.cpp @@ -30,106 +30,158 @@ #include #include -#include -#include +#include #include #include #include +#if defined(__linux__) +#include // PATH_MAX +#endif + #ifdef __APPLE__ +#include // PATH_MAX #include #endif -#include "os.hpp" - - -namespace os { - - -static pthread_mutex_t -mutex = PTHREAD_MUTEX_INITIALIZER; +#ifdef ANDROID +#include +#endif +#ifndef PATH_MAX +#warning PATH_MAX undefined +#define PATH_MAX 4096 +#endif -void -acquireMutex(void) -{ - pthread_mutex_lock(&mutex); -} +#include "os.hpp" +#include "os_string.hpp" -void -releaseMutex(void) -{ - pthread_mutex_unlock(&mutex); -} +namespace os { -Path +String getProcessName(void) { - Path path; - - char *szProcessPath = path.buf(PATH_MAX); + String path; + size_t size = PATH_MAX; + char *buf = path.buf(size); // http://stackoverflow.com/questions/1023306/finding-current-executables-path-without-proc-self-exe #ifdef __APPLE__ - uint32_t len = PATH_MAX; - if (_NSGetExecutablePath(szProcessPath, &len) != 0) { - *szProcessPath = 0; + uint32_t len = size; + if (_NSGetExecutablePath(buf, &len) != 0) { + *buf = 0; return path; } + len = strlen(buf); #else ssize_t len; - len = readlink("/proc/self/exe", szProcessPath, PATH_MAX - 1); + len = readlink("/proc/self/exe", buf, size - 1); if (len == -1) { // /proc/self/exe is not available on setuid processes, so fallback to // /proc/self/cmdline. int fd = open("/proc/self/cmdline", O_RDONLY); if (fd >= 0) { - len = read(fd, szProcessPath, PATH_MAX - 1); + len = read(fd, buf, size - 1); close(fd); } } if (len <= 0) { - snprintf(szProcessPath, PATH_MAX, "%i", (int)getpid()); + snprintf(buf, size, "%i", (int)getpid()); return path; } #endif - szProcessPath[len] = 0; path.truncate(len); return path; } -Path +String getCurrentDir(void) { - Path path; + String path; size_t size = PATH_MAX; - char *str = path.buf(size); - getcwd(str, size); - str[size - 1] = 0; + char *buf = path.buf(size); + + getcwd(buf, size); + buf[size - 1] = 0; + path.truncate(); return path; } +bool +String::exists(void) const +{ + struct stat st; + int err; + + err = stat(str(), &st); + if (err) { + return false; + } + + if (!S_ISREG(st.st_mode)) + return false; + + return true; +} + +int execute(char * const * args) +{ + pid_t pid = fork(); + if (pid == 0) { + // child + execvp(args[0], args); + fprintf(stderr, "error: failed to execute:"); + for (unsigned i = 0; args[i]; ++i) { + fprintf(stderr, " %s", args[i]); + } + fprintf(stderr, "\n"); + exit(-1); + } else { + // parent + if (pid == -1) { + fprintf(stderr, "error: failed to fork\n"); + return -1; + } + int status = -1; + int ret; + waitpid(pid, &status, 0); + if (WIFEXITED(status)) { + ret = WEXITSTATUS(status); + } else if (WIFSIGNALED(status)) { + // match shell return code + ret = WTERMSIG(status) + 128; + } else { + ret = 128; + } + return ret; + } +} + +static volatile bool logging = false; + void log(const char *format, ...) { + logging = true; va_list ap; va_start(ap, format); fflush(stdout); +#ifdef ANDROID + __android_log_vprint(ANDROID_LOG_DEBUG, "apitrace", format, ap); +#else vfprintf(stderr, format, ap); +#endif va_end(ap); + logging = false; } -long long -getTime(void) -{ - struct timeval tv; - gettimeofday(&tv, NULL); - return tv.tv_usec + tv.tv_sec*1000000LL; -} +#if defined(__APPLE__) +long long timeFrequency = 0LL; +#endif void abort(void) @@ -153,12 +205,22 @@ struct sigaction old_actions[NUM_SIGNALS]; static void signalHandler(int sig, siginfo_t *info, void *context) { + /* + * There are several signals that can happen when logging to stdout/stderr. + * For example, SIGPIPE will be emitted if stderr is a pipe with no + * readers. Therefore ignore any signal while logging by returning + * immediately, to prevent deadlocks. + */ + if (logging) { + return; + } + static int recursion_count = 0; - fprintf(stderr, "apitrace: warning: caught signal %i\n", sig); + log("apitrace: warning: caught signal %i\n", sig); if (recursion_count) { - fprintf(stderr, "apitrace: warning: recursion handling signal %i\n", sig); + log("apitrace: warning: recursion handling signal %i\n", sig); } else { if (gCallback) { ++recursion_count; @@ -170,7 +232,7 @@ signalHandler(int sig, siginfo_t *info, void *context) struct sigaction *old_action; if (sig >= NUM_SIGNALS) { /* This should never happen */ - fprintf(stderr, "error: unexpected signal %i\n", sig); + log("error: unexpected signal %i\n", sig); raise(SIGKILL); } old_action = &old_actions[sig]; @@ -180,7 +242,7 @@ signalHandler(int sig, siginfo_t *info, void *context) old_action->sa_sigaction(sig, info, context); } else { if (old_action->sa_handler == SIG_DFL) { - fprintf(stderr, "apitrace: info: taking default action for signal %i\n", sig); + log("apitrace: info: taking default action for signal %i\n", sig); #if 1 struct sigaction dfl_action; @@ -216,11 +278,26 @@ setExceptionCallback(void (*callback)(void)) for (int sig = 1; sig < NUM_SIGNALS; ++sig) { - // SIGKILL and SIGSTOP can't be handled - if (sig != SIGKILL && sig != SIGSTOP) { - if (sigaction(sig, NULL, &old_actions[sig]) >= 0) { - sigaction(sig, &new_action, NULL); - } + // SIGKILL and SIGSTOP can't be handled. + if (sig == SIGKILL || sig == SIGSTOP) { + continue; + } + + /* + * SIGPIPE can be emitted when writing to stderr that is redirected + * to a pipe without readers. It is also very unlikely to ocurr + * inside graphics APIs, and most applications where it can occur + * normally already ignore it. In summary, it is unlikely that a + * SIGPIPE will cause abnormal termination, which it is likely that + * intercepting here will cause problems, so simple don't intercept + * it here. + */ + if (sig == SIGPIPE) { + continue; + } + + if (sigaction(sig, NULL, &old_actions[sig]) >= 0) { + sigaction(sig, &new_action, NULL); } } }