[lldb] Make TestDeletedExecutable more reliable

[teemperor]

Summary

It seems that calling Popen can return to the caller before the started process has read all the needed information
from its executable. This means that in case we delete the executable while the process is still starting up,
this test will create a zombie process which in turn leads to a failing test. On my macOS system this happens quite frequently.

This patch fixes this by letting the test synchronize with the inferior after it has started up.

[friss]

This might mitigate the issue, but timeouts like this are bound to fail in some circumstances (machine load, ...). It's more work, but can we instead have the inferior produce an observable side effect (eg, print some output) and synchronize on this?

[davide]

Yeah, I'd rather have an explicit communication between debugger and debuggee.
We tried to put sleeps in the code [for e.g. lldb-mi tests in the past] and they end up failing anyway sporadically, which makes a pain to track the problem down.

[labath]

In D64546#1580618, @friss wrote:

This might mitigate the issue, but timeouts like this are bound to fail in some circumstances (machine load, ...). It's more work, but can we instead have the inferior produce an observable side effect (eg, print some output) and synchronize on this?

There's a lldbutil.wait_for_file_on_target, which was created exactly for this purpose.

[teemperor]

• Timeout -> file synchronization.
• Made the test process run longer just in case.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/deleted-executable/TestDeletedExecutable.py

 """
-Test process attach/resume.
+Test process attach when executable was deleted.
 """
 
 from __future__ import print_function
 
 
 import os
 import time
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestDeletedExecutable(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfWindows # cannot delete a running executable
     @expectedFailureAll(oslist=["linux"]) # determining the architecture of the process fails
     @expectedFailureNetBSD
     def test(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
 
-        popen = self.spawnSubprocess(exe)
+        # Use a file as a synchronization point between test and inferior.
+        pid_file_path = lldbutil.append_to_process_working_directory(self,
+            "token_pid_%d" % (int(os.getpid())))
+        self.addTearDownHook(
+            lambda: self.run_platform_command(
+                "rm %s" %
+                (pid_file_path)))
+
+        # Spawn a new process
+        popen = self.spawnSubprocess(exe, [pid_file_path])
         self.addTearDownHook(self.cleanupSubprocesses)
+
+        # Wait until process has fully started up.
+        pid = lldbutil.wait_for_file_on_target(self, pid_file_path)
+
+        # Now we can safely remove the executable and test if we can attach.
         os.remove(exe)
 
         self.runCmd("process attach -p " + str(popen.pid))
         self.runCmd("kill")

lldb/trunk/packages/Python/lldbsuite/test/functionalities/deleted-executable/main.cpp

 #include <chrono>
+#include <fstream>
 #include <thread>
 
-int main(int argc, char const *argv[])
-{
+int main(int argc, char const *argv[]) {
     lldb_enable_attach();
 
-    std::this_thread::sleep_for(std::chrono::seconds(30));
+    {
+      // Create file to signal that this process has started up.
+      std::ofstream f;
+      f.open(argv[1]);
+    }
+
+    std::this_thread::sleep_for(std::chrono::seconds(60));
 }