[TestAttachDenied] Use a file instead of a pipe for synchronization.

[sivachandra]

Summary

One cannot use mknod or mkfifo on user Android devices. This commit
changes the use of pipe to a file to synchronize between the inferior
and the test.

[ovyalov]

Did you try it remotely?

test/functionalities/process_attach/attach_denied/TestAttachDenied.py

53

Please add retcode to the assert message.

test/functionalities/process_attach/attach_denied/main.cpp

27–30

s/512/PATH_MAX ?

33

s/file_name/tmp_file_name

[chaoren]

test/functionalities/process_attach/attach_denied/TestAttachDenied.py

41

for _ in range(5)?

49

Maybe a shorter sleep at the beginning of the loop?

test/functionalities/process_attach/attach_denied/main.cpp

30

Why not fopen/fprintf?

[sivachandra]

Address comments.

[sivachandra]

test/functionalities/process_attach/attach_denied/TestAttachDenied.py

41

Done.

49

Implemented exponential backoff!

53

Done.

test/functionalities/process_attach/attach_denied/main.cpp

27–30

Done.

30

The idea of this change is to fix it for Android. Would prefer to stick to the minimum that is required for it.

33

Done.

[sivachandra]

BTW, I have tested it with a real nexus player.

[ovyalov]

Looks good.

[emaste]

test/functionalities/process_attach/attach_denied/main.cpp

8

Please don't put Linux-specific headers in common tests!

[ovyalov]

With this CL in is https://github.com/llvm-mirror/lldb/commit/8aca555d92918451fd852a71f6432c40b5bd7723 still relevant?

[chaoren]

The workaround is for Android, the timeout is for Linux. I don't think
they're related.

test/functionalities/process_attach/attach_denied/TestAttachDenied.py

 class AttachDeniedTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def run_platform_command(self, cmd):
         platform = self.dbg.GetSelectedPlatform()
         shell_command = lldb.SBPlatformShellCommand(cmd)
         err = platform.Run(shell_command)
-        return (err, shell_command.GetOutput())
+        return (err, shell_command.GetStatus(), shell_command.GetOutput())
 
     @skipIfWindows
     def test_attach_to_process_by_id_denied(self):
         """Test attach by process id denied"""
 
         self.buildDefault()
         exe = os.path.join(os.getcwd(), exe_name)
 
-        # Use named pipe as a synchronization point between test and inferior.
-        pid_pipe_path = os.path.join(self.get_process_working_directory(),
-                                     "pid_pipe_%d" % (int(time.time())))
-
-        triple = self.dbg.GetSelectedPlatform().GetTriple()
-        if re.match(".*-.*-.*-android", triple):
-            err, _ = self.run_platform_command("mknod %s p" % (pid_pipe_path))
-        else:
-            err, _ = self.run_platform_command("mkfifo %s" % (pid_pipe_path))
-
-        self.assertTrue(err.Success(), "Failed to create FIFO %s: %s" % (pid_pipe_path, err.GetCString()))
-
-        self.addTearDownHook(lambda: self.run_platform_command("rm %s" % (pid_pipe_path)))
+        # Use a file as a synchronization point between test and inferior.
+        pid_file_path = os.path.join(self.get_process_working_directory(),
+                                     "pid_file_%d" % (int(time.time())))
+        self.addTearDownHook(lambda: self.run_platform_command("rm %s" % (pid_file_path)))
 
         # Spawn a new process
-        popen = self.spawnSubprocess(exe, [pid_pipe_path])
+        popen = self.spawnSubprocess(exe, [pid_file_path])
         self.addTearDownHook(self.cleanupSubprocesses)
 
-        err, pid = self.run_platform_command("cat %s" % (pid_pipe_path))
-        self.assertTrue(err.Success(), "Failed to read FIFO %s: %s" % (pid_pipe_path, err.GetCString()))
+        max_attempts = 5
+        for i in range(max_attempts):
+            err, retcode, msg = self.run_platform_command("ls %s" % pid_file_path)
+            if err.Success() and retcode == 0:
+                break
+            else:
+                print msg
+            if i < max_attempts:
+                # Exponential backoff!
+                time.sleep(pow(2, i) * 0.25)
+        else:
+            self.fail("Child PID file %s not found even after %d attempts." % (pid_file_path, max_attempts))
+        err, retcode, pid = self.run_platform_command("cat %s" % (pid_file_path))
+        self.assertTrue(err.Success() and retcode == 0,
+                        "Failed to read file %s: %s, retcode: %d" % (pid_file_path, err.GetCString(), retcode))
 
         self.expect('process attach -p ' + pid,
                     startstr = 'error: attach failed:',
                     error = True)
 
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

test/functionalities/process_attach/attach_denied/main.cpp

 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 
+#include <linux/limits.h>
+
 #include <sys/types.h>
 #include <sys/ptrace.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
 
 #if defined(PTRACE_ATTACH)
 #define ATTACH_REQUEST PTRACE_ATTACH
 #define DETACH_REQUEST PTRACE_DETACH
 #elif defined(PT_ATTACH)
 #define ATTACH_REQUEST PT_ATTACH
 #define DETACH_REQUEST PT_DETACH
 #else
 #error "Unsupported platform"
 #endif
 
 bool writePid (const char* file_name, const pid_t pid)
 {
-    int fd = open (file_name, O_WRONLY);
+    char tmp_file_name[PATH_MAX];
+    strcpy(tmp_file_name, file_name);
+    strcat(tmp_file_name, "_tmp");
+    int fd = open (tmp_file_name, O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR);
     if (fd == -1)
     {
-        fprintf (stderr, "open(%s) failed: %s\n", file_name, strerror (errno));
+        fprintf (stderr, "open(%s) failed: %s\n", tmp_file_name, strerror (errno));
         return false;
     }
     char buffer[64];
     snprintf (buffer, sizeof(buffer), "%ld", (long)pid);
 
     bool res = true;
     if (write (fd, buffer, strlen (buffer)) == -1)
     {
         fprintf (stderr, "write(%s) failed: %s\n", buffer, strerror (errno));
         res = false;
     }
     close (fd);
+
+    if (rename (tmp_file_name, file_name) == -1)
+    {
+        fprintf (stderr, "rename(%s, %s) failed: %s\n", tmp_file_name, file_name, strerror (errno));
+        res = false;
+    }
+
     return res;
 }
 
 void sigterm_handler (int)
 {
 }
 
 int main (int argc, char const *argv[])