X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=common%2Fos_posix.cpp;h=967d12eba4116ddccd8f1c3389f165c7c8edc4c0;hb=b9c20609ce007c6e07562df57b8a5d845061b9e4;hp=37dd36431d391eaa90c8ce4df9bc69acea675107;hpb=22c30268664781adae88534fe5e91c10eb58e916;p=apitrace diff --git a/common/os_posix.cpp b/common/os_posix.cpp index 37dd364..967d12e 100644 --- a/common/os_posix.cpp +++ b/common/os_posix.cpp @@ -23,6 +23,7 @@ * **************************************************************************/ +#ifndef _WIN32 #include #include @@ -30,69 +31,74 @@ #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; - return path; + uint32_t len = size; + if (_NSGetExecutablePath(buf, &len) != 0) { + // grow buf and retry + buf = path.buf(len); + _NSGetExecutablePath(buf, &len); } + len = strlen(buf); #else ssize_t len; - len = readlink("/proc/self/exe", szProcessPath, PATH_MAX - 1); - if (len == -1) { + len = readlink("/proc/self/exe", buf, size - 1); + if (len <= 0) { // /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); + // buf already includes trailing zero + len = read(fd, buf, size); close(fd); + if (len >= 0) { + len = strlen(buf); + } } } if (len <= 0) { - snprintf(szProcessPath, PATH_MAX, "%i", (int)getpid()); - return path; + // fallback to process ID + len = snprintf(buf, size, "%i", (int)getpid()); + if (len >= size) { + len = size - 1; + } } #endif path.truncate(len); @@ -100,40 +106,108 @@ getProcessName(void) 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 +createDirectory(const String &path) +{ + return mkdir(path, 0777) == 0; +} + +bool +String::exists(void) const +{ + struct stat st; + int err; + + err = stat(str(), &st); + if (err) { + 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); - vfprintf(stderr, format, ap); +#ifdef ANDROID + __android_log_vprint(ANDROID_LOG_DEBUG, "apitrace", format, ap); +#else + static FILE *log = NULL; + if (!log) { + // Duplicate stderr file descriptor, to prevent applications from + // redirecting our debug messages to somewhere else. + // + // Another alternative would be to log to /dev/tty when available. + log = fdopen(dup(STDERR_FILENO), "at"); + } + vfprintf(log, format, ap); + fflush(log); +#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) { - exit(0); + _exit(1); } @@ -152,12 +226,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; @@ -169,7 +253,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]; @@ -179,7 +263,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; @@ -215,11 +299,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); } } } @@ -233,3 +332,4 @@ resetExceptionCallback(void) } /* namespace os */ +#endif // !defined(_WIN32)