| #include <cstdlib> |
| #include <cstring> |
| #include <errno.h> |
| #include <inttypes.h> |
| #include <memory> |
| #include <pthread.h> |
| #include <setjmp.h> |
| #include <signal.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <time.h> |
| #include <unistd.h> |
| #include <vector> |
| |
| #if defined(__APPLE__) |
| __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2) |
| int pthread_threadid_np(pthread_t,__uint64_t*); |
| #elif defined(__linux__) |
| #include <sys/syscall.h> |
| #endif |
| |
| static const char *const RETVAL_PREFIX = "retval:"; |
| static const char *const SLEEP_PREFIX = "sleep:"; |
| static const char *const STDERR_PREFIX = "stderr:"; |
| static const char *const SET_MESSAGE_PREFIX = "set-message:"; |
| static const char *const PRINT_MESSAGE_COMMAND = "print-message:"; |
| static const char *const GET_DATA_ADDRESS_PREFIX = "get-data-address-hex:"; |
| static const char *const GET_STACK_ADDRESS_COMMAND = "get-stack-address-hex:"; |
| static const char *const GET_HEAP_ADDRESS_COMMAND = "get-heap-address-hex:"; |
| |
| static const char *const GET_CODE_ADDRESS_PREFIX = "get-code-address-hex:"; |
| static const char *const CALL_FUNCTION_PREFIX = "call-function:"; |
| |
| static const char *const THREAD_PREFIX = "thread:"; |
| static const char *const THREAD_COMMAND_NEW = "new"; |
| static const char *const THREAD_COMMAND_PRINT_IDS = "print-ids"; |
| static const char *const THREAD_COMMAND_SEGFAULT = "segfault"; |
| |
| static bool g_print_thread_ids = false; |
| static pthread_mutex_t g_print_mutex = PTHREAD_MUTEX_INITIALIZER; |
| static bool g_threads_do_segfault = false; |
| |
| static pthread_mutex_t g_jump_buffer_mutex = PTHREAD_MUTEX_INITIALIZER; |
| static jmp_buf g_jump_buffer; |
| static bool g_is_segfaulting = false; |
| |
| static char g_message[256]; |
| |
| static volatile char g_c1 = '0'; |
| static volatile char g_c2 = '1'; |
| |
| static void |
| print_thread_id () |
| { |
| // Put in the right magic here for your platform to spit out the thread id (tid) that debugserver/lldb-gdbserver would see as a TID. |
| // Otherwise, let the else clause print out the unsupported text so that the unit test knows to skip verifying thread ids. |
| #if defined(__APPLE__) |
| __uint64_t tid = 0; |
| pthread_threadid_np(pthread_self(), &tid); |
| printf ("%" PRIx64, tid); |
| #elif defined (__linux__) |
| // This is a call to gettid() via syscall. |
| printf ("%" PRIx64, static_cast<uint64_t> (syscall (__NR_gettid))); |
| #else |
| printf("{no-tid-support}"); |
| #endif |
| } |
| |
| static void |
| signal_handler (int signo) |
| { |
| const char *signal_name = nullptr; |
| switch (signo) |
| { |
| case SIGUSR1: signal_name = "SIGUSR1"; break; |
| case SIGSEGV: signal_name = "SIGSEGV"; break; |
| default: signal_name = nullptr; |
| } |
| |
| // Print notice that we received the signal on a given thread. |
| pthread_mutex_lock (&g_print_mutex); |
| if (signal_name) |
| printf ("received %s on thread id: ", signal_name); |
| else |
| printf ("received signo %d (%s) on thread id: ", signo, strsignal (signo)); |
| print_thread_id (); |
| printf ("\n"); |
| pthread_mutex_unlock (&g_print_mutex); |
| |
| // Reset the signal handler if we're one of the expected signal handlers. |
| switch (signo) |
| { |
| case SIGSEGV: |
| if (g_is_segfaulting) |
| { |
| // Fix up the pointer we're writing to. This needs to happen if nothing intercepts the SIGSEGV |
| // (i.e. if somebody runs this from the command line). |
| longjmp(g_jump_buffer, 1); |
| } |
| break; |
| case SIGUSR1: |
| if (g_is_segfaulting) |
| { |
| // Fix up the pointer we're writing to. This is used to test gdb remote signal delivery. |
| // A SIGSEGV will be raised when the thread is created, switched out for a SIGUSR1, and |
| // then this code still needs to fix the seg fault. |
| // (i.e. if somebody runs this from the command line). |
| longjmp(g_jump_buffer, 1); |
| } |
| break; |
| } |
| |
| // Reset the signal handler. |
| sig_t sig_result = signal (signo, signal_handler); |
| if (sig_result == SIG_ERR) |
| { |
| fprintf(stderr, "failed to set signal handler: errno=%d\n", errno); |
| exit (1); |
| } |
| } |
| |
| static void |
| swap_chars () |
| { |
| g_c1 = '1'; |
| g_c2 = '0'; |
| |
| g_c1 = '0'; |
| g_c2 = '1'; |
| } |
| |
| static void |
| hello () |
| { |
| pthread_mutex_lock (&g_print_mutex); |
| printf ("hello, world\n"); |
| pthread_mutex_unlock (&g_print_mutex); |
| } |
| |
| static void* |
| thread_func (void *arg) |
| { |
| static pthread_mutex_t s_thread_index_mutex = PTHREAD_MUTEX_INITIALIZER; |
| static int s_thread_index = 1; |
| |
| pthread_mutex_lock (&s_thread_index_mutex); |
| const int this_thread_index = s_thread_index++; |
| pthread_mutex_unlock (&s_thread_index_mutex); |
| |
| if (g_print_thread_ids) |
| { |
| pthread_mutex_lock (&g_print_mutex); |
| printf ("thread %d id: ", this_thread_index); |
| print_thread_id (); |
| printf ("\n"); |
| pthread_mutex_unlock (&g_print_mutex); |
| } |
| |
| if (g_threads_do_segfault) |
| { |
| // Sleep for a number of seconds based on the thread index. |
| // TODO add ability to send commands to test exe so we can |
| // handle timing more precisely. This is clunky. All we're |
| // trying to do is add predictability as to the timing of |
| // signal generation by created threads. |
| int sleep_seconds = 2 * (this_thread_index - 1); |
| while (sleep_seconds > 0) |
| sleep_seconds = sleep(sleep_seconds); |
| |
| // Test creating a SEGV. |
| pthread_mutex_lock (&g_jump_buffer_mutex); |
| g_is_segfaulting = true; |
| int *bad_p = nullptr; |
| if (setjmp(g_jump_buffer) == 0) |
| { |
| // Force a seg fault signal on this thread. |
| *bad_p = 0; |
| } |
| else |
| { |
| // Tell the system we're no longer seg faulting. |
| // Used by the SIGUSR1 signal handler that we inject |
| // in place of the SIGSEGV so it only tries to |
| // recover from the SIGSEGV if this seg fault code |
| // was in play. |
| g_is_segfaulting = false; |
| } |
| pthread_mutex_unlock (&g_jump_buffer_mutex); |
| |
| pthread_mutex_lock (&g_print_mutex); |
| printf ("thread "); |
| print_thread_id (); |
| printf (": past SIGSEGV\n"); |
| pthread_mutex_unlock (&g_print_mutex); |
| } |
| |
| int sleep_seconds_remaining = 5; |
| while (sleep_seconds_remaining > 0) |
| { |
| sleep_seconds_remaining = sleep (sleep_seconds_remaining); |
| } |
| |
| return nullptr; |
| } |
| |
| int main (int argc, char **argv) |
| { |
| std::vector<pthread_t> threads; |
| std::unique_ptr<uint8_t[]> heap_array_up; |
| int return_value = 0; |
| |
| // Set the signal handler. |
| sig_t sig_result = signal (SIGALRM, signal_handler); |
| if (sig_result == SIG_ERR) |
| { |
| fprintf(stderr, "failed to set SIGALRM signal handler: errno=%d\n", errno); |
| exit (1); |
| } |
| |
| sig_result = signal (SIGUSR1, signal_handler); |
| if (sig_result == SIG_ERR) |
| { |
| fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno); |
| exit (1); |
| } |
| |
| sig_result = signal (SIGSEGV, signal_handler); |
| if (sig_result == SIG_ERR) |
| { |
| fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno); |
| exit (1); |
| } |
| |
| // Process command line args. |
| for (int i = 1; i < argc; ++i) |
| { |
| if (std::strstr (argv[i], STDERR_PREFIX)) |
| { |
| // Treat remainder as text to go to stderr. |
| fprintf (stderr, "%s\n", (argv[i] + strlen (STDERR_PREFIX))); |
| } |
| else if (std::strstr (argv[i], RETVAL_PREFIX)) |
| { |
| // Treat as the return value for the program. |
| return_value = std::atoi (argv[i] + strlen (RETVAL_PREFIX)); |
| } |
| else if (std::strstr (argv[i], SLEEP_PREFIX)) |
| { |
| // Treat as the amount of time to have this process sleep (in seconds). |
| int sleep_seconds_remaining = std::atoi (argv[i] + strlen (SLEEP_PREFIX)); |
| |
| // Loop around, sleeping until all sleep time is used up. Note that |
| // signals will cause sleep to end early with the number of seconds remaining. |
| for (int i = 0; sleep_seconds_remaining > 0; ++i) |
| { |
| sleep_seconds_remaining = sleep (sleep_seconds_remaining); |
| // std::cout << "sleep result (call " << i << "): " << sleep_seconds_remaining << std::endl; |
| } |
| } |
| else if (std::strstr (argv[i], SET_MESSAGE_PREFIX)) |
| { |
| // Copy the contents after "set-message:" to the g_message buffer. |
| // Used for reading inferior memory and verifying contents match expectations. |
| strncpy (g_message, argv[i] + strlen (SET_MESSAGE_PREFIX), sizeof (g_message)); |
| |
| // Ensure we're null terminated. |
| g_message[sizeof (g_message) - 1] = '\0'; |
| |
| } |
| else if (std::strstr (argv[i], PRINT_MESSAGE_COMMAND)) |
| { |
| pthread_mutex_lock (&g_print_mutex); |
| printf ("message: %s\n", g_message); |
| pthread_mutex_unlock (&g_print_mutex); |
| } |
| else if (std::strstr (argv[i], GET_DATA_ADDRESS_PREFIX)) |
| { |
| volatile void *data_p = nullptr; |
| |
| if (std::strstr (argv[i] + strlen (GET_DATA_ADDRESS_PREFIX), "g_message")) |
| data_p = &g_message[0]; |
| else if (std::strstr (argv[i] + strlen (GET_DATA_ADDRESS_PREFIX), "g_c1")) |
| data_p = &g_c1; |
| else if (std::strstr (argv[i] + strlen (GET_DATA_ADDRESS_PREFIX), "g_c2")) |
| data_p = &g_c2; |
| |
| pthread_mutex_lock (&g_print_mutex); |
| printf ("data address: %p\n", data_p); |
| pthread_mutex_unlock (&g_print_mutex); |
| } |
| else if (std::strstr (argv[i], GET_HEAP_ADDRESS_COMMAND)) |
| { |
| // Create a byte array if not already present. |
| if (!heap_array_up) |
| heap_array_up.reset (new uint8_t[32]); |
| |
| pthread_mutex_lock (&g_print_mutex); |
| printf ("heap address: %p\n", heap_array_up.get ()); |
| pthread_mutex_unlock (&g_print_mutex); |
| } |
| else if (std::strstr (argv[i], GET_STACK_ADDRESS_COMMAND)) |
| { |
| pthread_mutex_lock (&g_print_mutex); |
| printf ("stack address: %p\n", &return_value); |
| pthread_mutex_unlock (&g_print_mutex); |
| } |
| else if (std::strstr (argv[i], GET_CODE_ADDRESS_PREFIX)) |
| { |
| void (*func_p)() = nullptr; |
| |
| if (std::strstr (argv[i] + strlen (GET_CODE_ADDRESS_PREFIX), "hello")) |
| func_p = hello; |
| else if (std::strstr (argv[i] + strlen (GET_CODE_ADDRESS_PREFIX), "swap_chars")) |
| func_p = swap_chars; |
| |
| pthread_mutex_lock (&g_print_mutex); |
| printf ("code address: %p\n", func_p); |
| pthread_mutex_unlock (&g_print_mutex); |
| } |
| else if (std::strstr (argv[i], CALL_FUNCTION_PREFIX)) |
| { |
| // Defaut to providing the address of main. |
| if (std::strcmp (argv[i] + strlen (CALL_FUNCTION_PREFIX), "hello") == 0) |
| hello(); |
| else if (std::strcmp (argv[i] + strlen (CALL_FUNCTION_PREFIX), "swap_chars") == 0) |
| swap_chars(); |
| else |
| { |
| pthread_mutex_lock (&g_print_mutex); |
| printf ("unknown function: %s\n", argv[i] + strlen (CALL_FUNCTION_PREFIX)); |
| pthread_mutex_unlock (&g_print_mutex); |
| } |
| } |
| else if (std::strstr (argv[i], THREAD_PREFIX)) |
| { |
| // Check if we're creating a new thread. |
| if (std::strstr (argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_NEW)) |
| { |
| // Create a new thread. |
| pthread_t new_thread; |
| const int err = ::pthread_create (&new_thread, nullptr, thread_func, nullptr); |
| if (err) |
| { |
| fprintf (stderr, "pthread_create() failed with error code %d\n", err); |
| exit (err); |
| } |
| threads.push_back (new_thread); |
| } |
| else if (std::strstr (argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_PRINT_IDS)) |
| { |
| // Turn on thread id announcing. |
| g_print_thread_ids = true; |
| |
| // And announce us. |
| pthread_mutex_lock (&g_print_mutex); |
| printf ("thread 0 id: "); |
| print_thread_id (); |
| printf ("\n"); |
| pthread_mutex_unlock (&g_print_mutex); |
| } |
| else if (std::strstr (argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_SEGFAULT)) |
| { |
| g_threads_do_segfault = true; |
| } |
| else |
| { |
| // At this point we don't do anything else with threads. |
| // Later use thread index and send command to thread. |
| } |
| } |
| else |
| { |
| // Treat the argument as text for stdout. |
| printf("%s\n", argv[i]); |
| } |
| } |
| |
| // If we launched any threads, join them |
| for (std::vector<pthread_t>::iterator it = threads.begin (); it != threads.end (); ++it) |
| { |
| void *thread_retval = nullptr; |
| const int err = ::pthread_join (*it, &thread_retval); |
| if (err != 0) |
| fprintf (stderr, "pthread_join() failed with error code %d\n", err); |
| } |
| |
| return return_value; |
| } |