Centralize the handling of attach permissions on linux in tests

[labath]

Summary

On linux we need the process to give us special permissions before we can attach to it.
Previously, the code for this was copied into every file that needed it. This moves the code to a
central place to reduce code duplication.

[jingham]

Would you mind adding a note to README-TestSuite saying that you have to call this function if you want to attach to the binary you are building as part of the testsuite. As with all docs it's likely very few will read the note, but we ought to reward the superhumanly diligent...

[labath]

Good idea. I'll do that.

packages/Python/lldbsuite/test/driver/batch_mode/main.c

 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 
-#if defined(__linux__)
-#include <sys/prctl.h>
-#endif
-
 int 
 main (int argc, char **argv)
 {
-#if defined(__linux__)
-        // Immediately enable any ptracer so that we can allow the stub attach
-        // operation to succeed.  Some Linux kernels are locked down so that
-        // only an ancestor process can be a ptracer of a process.  This disables that
-        // restriction.  Without it, attach-related stub tests will fail.
-#if defined(PR_SET_PTRACER) && defined(PR_SET_PTRACER_ANY)
-        // For now we execute on best effort basis.  If this fails for
-        // some reason, so be it.
-        const int prctl_result = prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0);
-        (void) prctl_result;
-#endif
-#endif
+    lldb_enable_attach();
 
     int do_crash = 0;
     int do_wait = 0;
 
     int idx;
     for (idx = 1; idx < argc; idx++)
     {
         if (strcmp(argv[idx], "CRASH") == 0)

packages/Python/lldbsuite/test/functionalities/attach_resume/main.cpp

 #include <stdio.h>
 #include <fcntl.h>
 
 #include <chrono>
 #include <thread>
 
-#if defined(__linux__)
-#include <sys/prctl.h>
-#endif
-
 volatile bool debugger_flag = true; // The debugger will flip this to false
 
 void *start(void *data)
 {
     int i;
     size_t idx = (size_t)data;
     for (i=0; i<30; i++)
     {
         if ( idx == 0 && debugger_flag)
             std::this_thread::sleep_for(std::chrono::microseconds(1)); // Set breakpoint here
         std::this_thread::sleep_for(std::chrono::seconds(1));
     }
     return 0;
 }
 
 int main(int argc, char const *argv[])
 {
-#if defined(__linux__)
-    // Immediately enable any ptracer so that we can allow the stub attach
-    // operation to succeed.  Some Linux kernels are locked down so that
-    // only an ancestor process can be a ptracer of a process.  This disables that
-    // restriction.  Without it, attach-related stub tests will fail.
-#if defined(PR_SET_PTRACER) && defined(PR_SET_PTRACER_ANY)
-    // For now we execute on best effort basis.  If this fails for
-    // some reason, so be it.
-    const int prctl_result = prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0);
-    static_cast<void> (prctl_result);
-#endif
-#endif
+    lldb_enable_attach();
 
     static const size_t nthreads = 16;
     std::thread threads[nthreads];
     size_t i;
 
     for (i=0; i<nthreads; i++)
         threads[i] = std::move(std::thread(start, (void*)i));
 
     for (i=0; i<nthreads; i++)
         threads[i].join();
 }

packages/Python/lldbsuite/test/functionalities/process_attach/main.cpp

 #include <stdio.h>
 
-#if defined(__linux__)
-#include <sys/prctl.h>
-#endif
-
 #include <chrono>
 #include <thread>
 
 int main(int argc, char const *argv[]) {
     int temp;
-#if defined(__linux__)
-    // Immediately enable any ptracer so that we can allow the stub attach
-    // operation to succeed.  Some Linux kernels are locked down so that
-    // only an ancestor process can be a ptracer of a process.  This disables that
-    // restriction.  Without it, attach-related stub tests will fail.
-#if defined(PR_SET_PTRACER) && defined(PR_SET_PTRACER_ANY)
-    int prctl_result;
-
-    // For now we execute on best effort basis.  If this fails for
-    // some reason, so be it.
-    prctl_result = prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0);
-    (void) prctl_result;
-#endif
-#endif
+    lldb_enable_attach();
 
     // Waiting to be attached by the debugger.
     temp = 0;
 
     while (temp < 30) // Waiting to be attached...
     {
         std::this_thread::sleep_for(std::chrono::seconds(2));
         temp++;
     }
 
     printf("Exiting now\n");
 }

packages/Python/lldbsuite/test/functionalities/process_group/main.c

 #include <stdio.h>
 #include <unistd.h>
 #include <sys/wait.h>
 
-#if defined(__linux__)
-#include <sys/prctl.h>
-#endif
-
 volatile int release_child_flag = 0;
 
 int main(int argc, char const *argv[])
 {
     pid_t child = fork();
     if (child == -1)
     {
         perror("fork");
if (child > 0)
         if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
         {
             fprintf(stderr, "child did not exit correctly\n");
             return 7;
         }
     }
     else
     { // child
-#if defined(__linux__)
-        // Immediately enable any ptracer so that we can allow the stub attach
-        // operation to succeed.  Some Linux kernels are locked down so that
-        // only an ancestor process can be a ptracer of a process.  This disables that
-        // restriction.  Without it, attach-related stub tests will fail.
-#if defined(PR_SET_PTRACER) && defined(PR_SET_PTRACER_ANY)
-        // For now we execute on best effort basis.  If this fails for
-        // some reason, so be it.
-        const int prctl_result = prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0);
-        (void) prctl_result;
-#endif
-#endif
+        lldb_enable_attach();
 
         while (! release_child_flag) // Wait for debugger to attach
             sleep(1);
 
         printf("Child's previous process group is: %d\n", getpgid(0));
         setpgid(0, 0); // Set breakpoint here
         printf("Child's process group set to: %d\n", getpgid(0));
     }
 
     return 0;
 }

packages/Python/lldbsuite/test/functionalities/register/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include <stdio.h>
 
-#if defined(__linux__)
-#include <sys/prctl.h>
-#endif
-
 #include <chrono>
 #include <thread>
 
 long double outermost_return_long_double (long double my_long_double);
 
 int main (int argc, char const *argv[])
 {
-#if defined(__linux__)
-    // Immediately enable any ptracer so that we can allow the stub attach
-    // operation to succeed.  Some Linux kernels are locked down so that
-    // only an ancestor process can be a ptracer of a process.  This disables that
-    // restriction.  Without it, attach-related stub tests will fail.
-#if defined(PR_SET_PTRACER) && defined(PR_SET_PTRACER_ANY)
-    // For now we execute on best effort basis.  If this fails for
-    // some reason, so be it.
-    const int prctl_result = prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0);
-    static_cast<void> (prctl_result);
-#endif
-#endif
+    lldb_enable_attach();
 
     char my_string[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 0};
     double my_double = 1234.5678;
     long double my_long_double = 1234.5678;
 
     // For simplicity assume that any cmdline argument means wait for attach.
     if (argc > 1)
     {

packages/Python/lldbsuite/test/functionalities/thread/create_after_attach/main.cpp

 #include <stdio.h>
 #include <chrono>
 #include <thread>
 
 using std::chrono::microseconds;
 
-#if defined(__linux__)
-#include <sys/prctl.h>
-#endif
-
 volatile int g_thread_2_continuing = 0;
 
 void *
 thread_1_func (void *input)
 {
     // Waiting to be released by the debugger.
     while (!g_thread_2_continuing) // Another thread will change this value
     {
thread_2_func (void *input)
     g_thread_2_continuing = 1;
 
     // Return
     return NULL;
 }
 
 int main(int argc, char const *argv[])
 {
-#if defined(__linux__)
-    // Immediately enable any ptracer so that we can allow the stub attach
-    // operation to succeed.  Some Linux kernels are locked down so that
-    // only an ancestor process can be a ptracer of a process.  This disables that
-    // restriction.  Without it, attach-related stub tests will fail.
-#if defined(PR_SET_PTRACER) && defined(PR_SET_PTRACER_ANY)
-    int prctl_result;
-
-    // For now we execute on best effort basis.  If this fails for
-    // some reason, so be it.
-    prctl_result = prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0);
-    (void) prctl_result;
-#endif
-#endif
+    lldb_enable_attach();
 
     // Create a new thread
     std::thread thread_1(thread_1_func, nullptr);
 
     // Waiting to be attached by the debugger.
     int main_thread_continue = 0;
     while (!main_thread_continue) // The debugger will change this value
     {

packages/Python/lldbsuite/test/make/test_common.h

 
 #if defined(__cplusplus) && defined(_MSC_VER) && (_HAS_EXCEPTIONS == 0)
 // Compiling MSVC libraries with _HAS_EXCEPTIONS=0, eliminates most but not all
 // calls to __uncaught_exception.  Unfortunately, it does seem to eliminate
 // the delcaration of __uncaught_excpeiton.  Including <eh.h> ensures that it is
 // declared.  This may not be necessary after MSVC 12.
 #include <eh.h>
 #endif
+
+
+// On some systems (e.g., some versions of linux) it is not possible to attach to a process
+// without it giving us special permissions. This defines the lldb_enable_attach macro, which
+// should perform any such actions, if needed by the platform. This is a macro instead of a
+// function to avoid the need for complex linking of the test programs.
+#if defined(__linux__)
+#include <sys/prctl.h>
+
+#if defined(PR_SET_PTRACER) && defined(PR_SET_PTRACER_ANY)
+// For now we execute on best effort basis.  If this fails for some reason, so be it.
+#define lldb_enable_attach()                                                          \
+    do                                                                                \
+    {                                                                                 \
+        const int prctl_result = prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0);  \
+        (void)prctl_result;                                                           \
+    } while (0)
+
+#endif
+
+#else // not linux
+
+#define lldb_enable_attach()
+
+#endif

packages/Python/lldbsuite/test/python_api/hello_world/main.c

 #include <stdio.h>
 
-#if defined(__linux__)
-#include <sys/prctl.h>
-#endif
-
-int main(int argc, char const *argv[]) {
-
-#if defined(__linux__)
-    // Immediately enable any ptracer so that we can allow the stub attach
-    // operation to succeed.  Some Linux kernels are locked down so that
-    // only an ancestor process can be a ptracer of a process.  This disables that
-    // restriction.  Without it, attach-related stub tests will fail.
-#if defined(PR_SET_PTRACER) && defined(PR_SET_PTRACER_ANY)
-    int prctl_result;
-
-    // For now we execute on best effort basis.  If this fails for
-    // some reason, so be it.
-    prctl_result = prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0);
-    (void) prctl_result;
-#endif
-#endif
+int main(int argc, char const *argv[])
+{
+    lldb_enable_attach();
 
     printf("Hello world.\n"); // Set break point at this line.
     if (argc == 1)
         return 0;
 
     // Waiting to be attached by the debugger, otherwise.
     char line[100];
     while (fgets(line, sizeof(line), stdin)) { // Waiting to be attached...
         printf("input line=>%s\n", line);
     }
 
     printf("Exiting now\n");
 }

packages/Python/lldbsuite/test/tools/lldb-server/main.cpp

 
 #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
 
-#if defined(__linux__)
-#include <sys/prctl.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:";
while (sleep_seconds_remaining > 0)
     sleep_seconds_remaining = sleep (sleep_seconds_remaining);
   }
 
   return nullptr;
 }
 
 int main (int argc, char **argv)
 {
-#if defined(__linux__)
-    // Immediately enable any ptracer so that we can allow the stub attach
-    // operation to succeed.  Some Linux kernels are locked down so that
-    // only an ancestor can be a ptracer of a process.  This disables that
-    // restriction.  Without it, attach-related stub tests will fail.
-#if defined(PR_SET_PTRACER) && defined(PR_SET_PTRACER_ANY)
-    const int prctl_result = prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0);
-    static_cast<void> (prctl_result);
-#endif
-#endif
+  lldb_enable_attach();
 
   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)