Fix descriptor leak in multi-target debugging

[labath]

Summary

When debugging two targets concurrently, the pseude terminal master fd from the first one would
leak into the second. This fixes the problem by setting O_CLOEXEC on the master fd. Test
included.

[emaste]

I can't fully confirm the fix on FreeBSD at the moment due to python leaking an fd, but LGTM.

https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=197376 but

source/Utility/PseudoTerminal.cpp

262 ↗

(On Diff #19482)

in case O_CLOEXEC fails or is unsupported?

[clayborg]

Looks good.

[zturner]

Hi, please be careful with O_CLOEXEC in the future. I've had to fix two
patches on Windows in the past week because of it. It's not the end of the
world, but just keep in mind next time using it that it doesn't exist on
Windows so you'll need to wrap its use in an #if defined(_MSC_VER)

[labath]

I'm sorry about that.

I _was_ thinking about windows, but I was like: the function is called Terminal::Fork, there is no way that can be used on windows... :)

Anyway, I should be done with this now. Thanks for fixing it up.

[zturner]

Heh. Sooner or later this entire file needs to be compiled out on Windows,
so your thinking was pretty close :)

lldb/trunk/source/Utility/PseudoTerminal.cpp

 //----------------------------------------------------------------------
 lldb::pid_t
 PseudoTerminal::Fork (char *error_str, size_t error_len)
 {
     if (error_str)
         error_str[0] = '\0';
 
     pid_t pid = LLDB_INVALID_PROCESS_ID;
-    if (OpenFirstAvailableMaster (O_RDWR, error_str, error_len))
+    if (OpenFirstAvailableMaster (O_RDWR | O_CLOEXEC, error_str, error_len))
     {
         // Successfully opened our master pseudo terminal
 
         pid = ::fork ();
         if (pid < 0)
         {
             // Fork failed
             if (error_str)
             ::strerror_r (errno, error_str, error_len);
         }
         else if (pid == 0)
         {
             // Child Process
             ::setsid();
 
             if (OpenSlave (O_RDWR, error_str, error_len))
             {
                 // Successfully opened slave
-                // We are done with the master in the child process so lets close it
+
+                // Master FD should have O_CLOEXEC set, but let's close it just in case...
                 CloseMasterFileDescriptor ();
 
 #if defined(TIOCSCTTY)
                 // Acquire the controlling terminal
                 if (::ioctl (m_slave_fd, TIOCSCTTY, (char *)0) < 0)
                 {
                     if (error_str)
                         ::strerror_r (errno, error_str, error_len);

lldb/trunk/test/functionalities/avoids-fd-leak/TestFdLeak.py

def do_test (self, commands):
 
         process = target.LaunchSimple (None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         self.assertTrue(process.GetState() == lldb.eStateExited, "Process should have exited.")
         self.assertTrue(process.GetExitStatus() == 0,
                 "Process returned non-zero status. Were incorrect file descriptors passed?")
 
+    @skipIfWindows # The check for descriptor leakage needs to be implemented differently here.
+    def test_fd_leak_multitarget (self):
+        self.buildDefault()
+        exe = os.path.join (os.getcwd(), "a.out")
+
+        target = self.dbg.CreateTarget(exe)
+
+        listener = lldb.SBListener()
+        error = lldb.SBError()
+        process1 = target.Launch (listener, None, None, None, None, None,
+                self.get_process_working_directory(), 0, True, # stop at entry
+                error)
+        self.assertTrue(process1, PROCESS_IS_VALID)
+        self.assertTrue(process1.GetState() == lldb.eStateStopped, "Process should have been stopped.")
+
+        target2 = self.dbg.CreateTarget(exe)
+        process2 = target2.LaunchSimple (None, None, self.get_process_working_directory())
+        self.assertTrue(process2, PROCESS_IS_VALID)
+
+        self.assertTrue(process2.GetState() == lldb.eStateExited, "Process should have exited.")
+        self.assertTrue(process2.GetExitStatus() == 0,
+                "Process returned non-zero status. Were incorrect file descriptors passed?")
+
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()