Avoid leaking log file descriptors into the inferior process.

[labath]

Summary

This commit adds a new open flag File::eOpenOptionCloseOnExec (i.e., O_CLOEXEC), and adds it to
the list of flags when opening log files (#ifndef windows). A regression test is included.

[tberghammer]

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

19 ↗

(On Diff #19322)

I think the test should be marked as skipped instead of expected failure because it is a problem in the test suit and not in lldb itself.

[clayborg]

lgtm

lldb/trunk/include/lldb/Host/File.h

public:
     {
         eOpenOptionRead                 = (1u << 0),    // Open file for reading
         eOpenOptionWrite                = (1u << 1),    // Open file for writing
         eOpenOptionAppend               = (1u << 2),    // Don't truncate file when opening, append to end of file
         eOpenOptionTruncate             = (1u << 3),    // Truncate file when opening
         eOpenOptionNonBlocking          = (1u << 4),    // File reads
         eOpenOptionCanCreate            = (1u << 5),    // Create file if doesn't already exist
         eOpenOptionCanCreateNewOnly     = (1u << 6),    // Can create file only if it doesn't already exist
-        eOpenoptionDontFollowSymlinks   = (1u << 7)
+        eOpenoptionDontFollowSymlinks   = (1u << 7),
+        eOpenOptionCloseOnExec          = (1u << 8)     // Close the file when executing a new process
     };
     
     static mode_t
     ConvertOpenOptionsForPOSIXOpen (uint32_t open_options);
     
     File() : 
         IOObject(eFDTypeFile, false),
         m_descriptor (kInvalidDescriptor),

lldb/trunk/source/Core/StreamFile.cpp

 StreamFile::StreamFile (FILE *fh, bool transfer_ownership) :
     Stream (),
     m_file (fh, transfer_ownership)
 {
 }
 
 StreamFile::StreamFile (const char *path) :
     Stream (),
-    m_file (path, File::eOpenOptionWrite | File::eOpenOptionCanCreate, lldb::eFilePermissionsFileDefault)
+    m_file (path, File::eOpenOptionWrite | File::eOpenOptionCanCreate | File::eOpenOptionCloseOnExec,
+                    lldb::eFilePermissionsFileDefault)
 {
 }
 
 
 StreamFile::~StreamFile()
 {
 }
 

lldb/trunk/source/Host/common/File.cpp

#ifndef _WIN32
         if (options & eOpenoptionDontFollowSymlinks)
             oflag |= O_NOFOLLOW;
 #endif
     }
     
 #ifndef _WIN32
     if (options & eOpenOptionNonBlocking)
         oflag |= O_NONBLOCK;
+    if (options & eOpenOptionCloseOnExec)
+        oflag |= O_CLOEXEC;
 #else
     oflag |= O_BINARY;
 #endif
 
     mode_t mode = 0;
     if (oflag & O_CREAT)
     {
         if (permissions & lldb::eFilePermissionsUserRead)     mode |= S_IRUSR;

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

 """
 Test whether a process started by lldb has no extra file descriptors open.
 """
 
 import os
 import unittest2
 import lldb
 from lldbtest import *
 import lldbutil
 
 class AvoidsFdLeakTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("The check for descriptor leakage needs to be implemented differently")
-    def test_fd_leak (self):
+    @skipIfWindows # The check for descriptor leakage needs to be implemented differently here.
+    def test_fd_leak_basic (self):
+        self.do_test([])
+
+    @skipIfWindows # The check for descriptor leakage needs to be implemented differently here.
+    def test_fd_leak_log (self):
+        self.do_test(["log enable -f '/dev/null' lldb commands"])
+
+    def do_test (self, commands):
         self.buildDefault()
         exe = os.path.join (os.getcwd(), "a.out")
 
+        for c in commands:
+            self.runCmd(c)
+
         target = self.dbg.CreateTarget(exe)
 
         process = target.LaunchSimple (None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
-        self.assertTrue(process.GetState() == lldb.eStateExited)
-        self.assertTrue(process.GetExitStatus() == 0)
+        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?")
+
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()