Bug 23051 - Fix zombie processes after lldb-server tests

[ki.stfu]

Summary

This patch fixes the following bug: https://llvm.org/bugs/show_bug.cgi?id=23181
For some reason some lldb-server tests should be kicked using SIGHUP and SIGINT before termination, otherwise it will leave a zombie process.
I think the reason is that the lldb-server will terminate a slave process if it gets the SIGHUP/SIGINT and if so it should be fixed in lldb-server.

The solution is to terminate process like it does the pexpect (including the delayafterterminate interval).

Also this patch reverts the following commits:

• r234549 - Skip lldb-server tests according to bug 23181
• r234765 - Skip a few tests on OS X according to the bug 23181
• r234803 - Skip the TestGdbRemoteRegisterState.test_grp_register_save_restore_works_no_suffix_debugserver_dsym test on OS X according to the bug 23181

[tberghammer]

Thanks for looking into it.

test/lldbtest.py

284–289

I think we should use kill() here to be sure the process is stopped (or add one more layer where we first do a terminate and if it is unsuccessful then do a kill).

[ki.stfu]

test/lldbtest.py

284–289

I have thought about this, ok. BTW, the pexpect also sends SIGCONT, but I didn't understand why it's needed. Should I use it too or not?

[tberghammer]

test/lldbtest.py

284–289

I have no idea why it sends SIGCONT. I think if you send a SIGKILL then the process should die in any condition so sending a SIGCONT isn't necessary but I might be wrong.

[ki.stfu]

Send SIGCONT and SIGKILL signals on termination

test/functionalities/register/TestRegisters.py

class RegisterCommandsTestCase(TestBase):
     @expectedFailureFreeBSD("llvm.org/pr18200")
     def test_convenience_registers_with_process_attach(self):
         """Test convenience registers after a 'process attach'."""
         if not self.getArchitecture() in ['amd64', 'x86_64']:
             self.skipTest("This test requires x86_64 as the architecture for the inferior")
         self.buildDefault()
         self.convenience_registers_with_process_attach(test_16bit_regs=False)
 
-    @skipIfDarwin # https://llvm.org/bugs/show_bug.cgi?id=23181: Some lldb-server tests become zombies
     @skipIfFreeBSD # llvm.org/pr18230
     @expectedFailureFreeBSD("llvm.org/pr18200")
     def test_convenience_registers_16bit_with_process_attach(self):
         """Test convenience registers after a 'process attach'."""
         if not self.getArchitecture() in ['amd64', 'x86_64']:
             self.skipTest("This test requires x86_64 as the architecture for the inferior")
         self.buildDefault()
         self.convenience_registers_with_process_attach(test_16bit_regs=True)

test/lldbtest.py

class _BaseProcess(object):
     def terminate(self):
         """Terminates previously launched process.."""
 
 class _LocalProcess(_BaseProcess):
 
     def __init__(self, trace_on):
         self._proc = None
         self._trace_on = trace_on
+        self._delayafterterminate = 0.1
 
     @property
     def pid(self):
         return self._proc.pid
 
     def launch(self, executable, args):
         self._proc = Popen([executable] + args,
                            stdout = open(os.devnull) if not self._trace_on else None,
                            stdin = PIPE)
 
     def terminate(self):
         if self._proc.poll() == None:
+            # Terminate _proc like it does the pexpect
+            self._proc.send_signal(signal.SIGHUP)
+            time.sleep(self._delayafterterminate)
+            if self._proc.poll() != None:
+                return
+            self._proc.send_signal(signal.SIGCONT)
+            time.sleep(self._delayafterterminate)
+            if self._proc.poll() != None:
+                return
+            self._proc.send_signal(signal.SIGINT)
+            time.sleep(self._delayafterterminate)
+            if self._proc.poll() != None:
+                return
             self._proc.terminate()
+            time.sleep(self._delayafterterminate)
+            if self._proc.poll() != None:
+                return
+            self._proc.kill()
+            time.sleep(self._delayafterterminate)
 
     def poll(self):
         return self._proc.poll()
 
 class _RemoteProcess(_BaseProcess):
 
     def __init__(self, install_remote):
         self._pid = None

test/tools/lldb-server/TestGdbRemoteRegisterState.py

def test_grp_register_save_restore_works_with_suffix_llgs_dwarf(self):
         USE_THREAD_SUFFIX = True
         self.init_llgs_test()
         self.buildDwarf()
         self.set_inferior_startup_launch()
         self.grp_register_save_restore_works(USE_THREAD_SUFFIX)
 
     @debugserver_test
     @dsym_test
-    @skipIfDarwin # https://llvm.org/bugs/show_bug.cgi?id=23181: Some lldb-server tests become zombies
     def test_grp_register_save_restore_works_no_suffix_debugserver_dsym(self):
         USE_THREAD_SUFFIX = False
         self.init_debugserver_test()
         self.buildDsym()
         self.set_inferior_startup_launch()
         self.grp_register_save_restore_works(USE_THREAD_SUFFIX)
 
     @llgs_test

test/tools/lldb-server/TestGdbRemoteSingleStep.py

 import unittest2
 
 import gdbremote_testcase
 from lldbtest import *
 
 class TestGdbRemoteSingleStep(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     @debugserver_test
     @dsym_test
-    @skipIfDarwin # https://llvm.org/bugs/show_bug.cgi?id=23181: Some lldb-server tests become zombies
     def test_single_step_only_steps_one_instruction_with_s_debugserver_dsym(self):
         self.init_debugserver_test()
         self.buildDsym()
         self.set_inferior_startup_launch()
         self.single_step_only_steps_one_instruction(use_Hc_packet=True, step_instruction="s")
 
     @llgs_test
     @dwarf_test
     def test_single_step_only_steps_one_instruction_with_s_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.set_inferior_startup_launch()
         self.single_step_only_steps_one_instruction(use_Hc_packet=True, step_instruction="s")
 
 if __name__ == '__main__':
     unittest2.main()

test/tools/lldb-server/TestGdbRemote_vCont.py

class TestGdbRemote_vCont(gdbremote_testcase.GdbRemoteTestCaseBase):
     @dwarf_test
     def test_vCont_supports_S_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.vCont_supports_S()
 
     @debugserver_test
     @dsym_test
-    @skipIfDarwin # https://llvm.org/bugs/show_bug.cgi?id=23181: Some lldb-server tests become zombies
     def test_single_step_only_steps_one_instruction_with_Hc_vCont_s_debugserver_dsym(self):
         self.init_debugserver_test()
         self.buildDsym()
         self.set_inferior_startup_launch()
         self.single_step_only_steps_one_instruction(use_Hc_packet=True, step_instruction="vCont;s")
 
     @llgs_test
     @dwarf_test
     def test_single_step_only_steps_one_instruction_with_Hc_vCont_s_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.set_inferior_startup_launch()
         self.single_step_only_steps_one_instruction(use_Hc_packet=True, step_instruction="vCont;s")
 
     @debugserver_test
     @dsym_test
-    @skipIfDarwin # https://llvm.org/bugs/show_bug.cgi?id=23181: Some lldb-server tests become zombies
     def test_single_step_only_steps_one_instruction_with_vCont_s_thread_debugserver_dsym(self):
         self.init_debugserver_test()
         self.buildDsym()
         self.set_inferior_startup_launch()
         self.single_step_only_steps_one_instruction(use_Hc_packet=False, step_instruction="vCont;s:{thread}")
 
     @llgs_test
     @dwarf_test

test/tools/lldb-server/TestLldbGdbServer.py

class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
     def test_p_returns_correct_data_size_for_each_qRegisterInfo_launch_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.set_inferior_startup_launch()
         self.p_returns_correct_data_size_for_each_qRegisterInfo()
 
     @debugserver_test
     @dsym_test
-    @skipIfDarwin # https://llvm.org/bugs/show_bug.cgi?id=23181: Some lldb-server tests become zombies
     def test_p_returns_correct_data_size_for_each_qRegisterInfo_attach_debugserver_dsym(self):
         self.init_debugserver_test()
         self.buildDsym()
         self.set_inferior_startup_attach()
         self.p_returns_correct_data_size_for_each_qRegisterInfo()
 
     @llgs_test
     @dwarf_test
def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):
             # Ensure post signal-handle thread id matches the thread that initially raised the SIGSEGV.
             post_handle_thread_id = context.get("post_handle_thread_id")
             self.assertIsNotNone(post_handle_thread_id)
             post_handle_thread_id = int(post_handle_thread_id, 16)
             self.assertEquals(post_handle_thread_id, print_thread_id)
 
     @debugserver_test
     @dsym_test
-    @skipIfDarwin # https://llvm.org/bugs/show_bug.cgi?id=23181: Some lldb-server tests become zombies
     @unittest2.expectedFailure()
     def test_Hc_then_Csignal_signals_correct_thread_launch_debugserver_dsym(self):
         self.init_debugserver_test()
         self.buildDsym()
         self.set_inferior_startup_launch()
         # Darwin debugserver translates some signals like SIGSEGV into some gdb expectations about fixed signal numbers.
         self.Hc_then_Csignal_signals_correct_thread(self.TARGET_EXC_BAD_ACCESS)
 

test/tools/lldb-server/inferior-crash/TestGdbRemoteAbort.py

def inferior_abort_received(self):
         self.assertIsNotNone(context)
 
         hex_exit_code = context.get("hex_exit_code")
         self.assertIsNotNone(hex_exit_code)
         self.assertEquals(int(hex_exit_code, 16), signal.SIGABRT)
 
     @debugserver_test
     @dsym_test
-    @skipIfDarwin # https://llvm.org/bugs/show_bug.cgi?id=23181: Some lldb-server tests become zombies
     def test_inferior_abort_received_debugserver_dsym(self):
         self.init_debugserver_test()
         self.buildDsym()
         self.inferior_abort_received()
 
     @llgs_test
     @dwarf_test
     def test_inferior_abort_received_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.inferior_abort_received()
 

test/tools/lldb-server/inferior-crash/TestGdbRemoteSegFault.py

def inferior_seg_fault_received(self, expected_signo):
         self.assertIsNotNone(context)
 
         hex_exit_code = context.get("hex_exit_code")
         self.assertIsNotNone(hex_exit_code)
         self.assertEquals(int(hex_exit_code, 16), expected_signo)
 
     @debugserver_test
     @dsym_test
-    @skipIfDarwin # https://llvm.org/bugs/show_bug.cgi?id=23181: Some lldb-server tests become zombies
     def test_inferior_seg_fault_received_debugserver_dsym(self):
         self.init_debugserver_test()
         self.buildDsym()
         self.inferior_seg_fault_received(self.GDB_REMOTE_STOP_CODE_BAD_ACCESS)
 
     @llgs_test
     @dwarf_test
     def test_inferior_seg_fault_received_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.inferior_seg_fault_received(signal.SIGSEGV)