Support for truncate/append on log files

[labath]

Summary

Presently, if a log file already exists, lldb simply starts overwriting bits of it, without
truncating or anything. This patch makes it use eFileOptionFileTruncate by default. It also adds
an --append option, which will append to the file without truncating. A test is included.

[clayborg]

lgtm

include/lldb/Core/Log.h

 #define LLDB_LOG_OPTION_THREADSAFE              (1u << 0)
 #define LLDB_LOG_OPTION_VERBOSE                 (1u << 1)
 #define LLDB_LOG_OPTION_DEBUG                   (1u << 2)
 #define LLDB_LOG_OPTION_PREPEND_SEQUENCE        (1u << 3)
 #define LLDB_LOG_OPTION_PREPEND_TIMESTAMP       (1u << 4)
 #define LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD (1u << 5)
 #define LLDB_LOG_OPTION_PREPEND_THREAD_NAME     (1U << 6)
 #define LLDB_LOG_OPTION_BACKTRACE               (1U << 7)
+#define LLDB_LOG_OPTION_APPEND                  (1U << 8)
 
 //----------------------------------------------------------------------
 // Logging Functions
 //----------------------------------------------------------------------
 namespace lldb_private {
 
 class Log
 {

include/lldb/Core/StreamFile.h

public:
     StreamFile ();
 
     StreamFile (uint32_t flags, uint32_t addr_size, lldb::ByteOrder byte_order);
 
     StreamFile (int fd, bool transfer_ownership);
 
     StreamFile (const char *path);
 
+    StreamFile (const char *path,
+                uint32_t options,
+                uint32_t permissions = lldb::eFilePermissionsFileDefault);
+
     StreamFile (FILE *fh, bool transfer_ownership);
 
     virtual
     ~StreamFile();
 
     File &
     GetFile ()
     {

source/Commands/CommandObjectLog.cpp

public:
             case 't':  log_options |= LLDB_LOG_OPTION_THREADSAFE;             break;
             case 'v':  log_options |= LLDB_LOG_OPTION_VERBOSE;                break;
             case 'g':  log_options |= LLDB_LOG_OPTION_DEBUG;                  break;
             case 's':  log_options |= LLDB_LOG_OPTION_PREPEND_SEQUENCE;       break;
             case 'T':  log_options |= LLDB_LOG_OPTION_PREPEND_TIMESTAMP;      break;
             case 'p':  log_options |= LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD;break;
             case 'n':  log_options |= LLDB_LOG_OPTION_PREPEND_THREAD_NAME;    break;
             case 'S':  log_options |= LLDB_LOG_OPTION_BACKTRACE;              break;
+            case 'a':  log_options |= LLDB_LOG_OPTION_APPEND;                 break;
             default:
                 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                 break;
             }
 
             return error;
         }
 

 { LLDB_OPT_SET_1, false, "threadsafe", 't', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone,        "Enable thread safe logging to avoid interweaved log lines." },
 { LLDB_OPT_SET_1, false, "verbose",    'v', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone,       "Enable verbose logging." },
 { LLDB_OPT_SET_1, false, "debug",      'g', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone,       "Enable debug logging." },
 { LLDB_OPT_SET_1, false, "sequence",   's', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone,       "Prepend all log lines with an increasing integer sequence id." },
 { LLDB_OPT_SET_1, false, "timestamp",  'T', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone,       "Prepend all log lines with a timestamp." },
 { LLDB_OPT_SET_1, false, "pid-tid",    'p', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone,       "Prepend all log lines with the process and thread ID that generates the log line." },
 { LLDB_OPT_SET_1, false, "thread-name",'n', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone,       "Prepend all log lines with the thread name for the thread that generates the log line." },
 { LLDB_OPT_SET_1, false, "stack",      'S', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone,       "Append a stack backtrace to each log line." },
+{ LLDB_OPT_SET_1, false, "append",     'a', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone,       "Append to the log file instead of overwriting." },
 { 0, false, NULL,                       0,  0,                 NULL, NULL, 0, eArgTypeNone,       NULL }
 };
 
 class CommandObjectLogDisable : public CommandObjectParsed
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors

source/Core/Debugger.cpp

Debugger::EnableLog (const char *channel, const char **categories, const char *log_file, uint32_t log_options, Stream &error_stream)
     }
     else
     {
         LogStreamMap::iterator pos = m_log_streams.find(log_file);
         if (pos != m_log_streams.end())
             log_stream_sp = pos->second.lock();
         if (!log_stream_sp)
         {
-            log_stream_sp.reset (new StreamFile (log_file));
+            uint32_t options = File::eOpenOptionWrite | File::eOpenOptionCanCreate
+                                | File::eOpenOptionCloseOnExec | File::eOpenOptionAppend;
+            if (! (log_options & LLDB_LOG_OPTION_APPEND))
+                options |= File::eOpenOptionTruncate;
+
+            log_stream_sp.reset (new StreamFile (log_file, options));
             m_log_streams[log_file] = log_stream_sp;
         }
     }
     assert (log_stream_sp.get());
     
     if (log_options == 0)
         log_options = LLDB_LOG_OPTION_PREPEND_THREAD_NAME | LLDB_LOG_OPTION_THREADSAFE;
         

source/Core/StreamFile.cpp

 
 StreamFile::StreamFile (const char *path) :
     Stream (),
     m_file (path, File::eOpenOptionWrite | File::eOpenOptionCanCreate | File::eOpenOptionCloseOnExec,
                     lldb::eFilePermissionsFileDefault)
 {
 }
 
+StreamFile::StreamFile (const char *path,
+                        uint32_t options,
+                        uint32_t permissions) :
+    Stream(),
+    m_file(path, options, permissions)
+{
+}
 
 StreamFile::~StreamFile()
 {
 }
 
 void
 StreamFile::Flush ()
 {

test/logging/TestLogging.py

 """
 Test lldb logging.  This test just makes sure logging doesn't crash, and produces some output.
 """
 
-import os, time
+import os, time, string
 import unittest2
 import lldb
 from lldbtest import *
 
 class LogTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    append_log_file = "lldb-commands-log-append.txt"
+    truncate_log_file = "lldb-commands-log-truncate.txt"
+
+
+    @classmethod
+    def classCleanup(cls):
+        """Cleanup the test byproducts."""
+        cls.RemoveTempFile(cls.truncate_log_file)
+        cls.RemoveTempFile(cls.append_log_file)
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     @dsym_test
     def test_with_dsym (self):
         self.buildDsym ()
         self.command_log_tests ("dsym")
 
     @dwarf_test
def command_log_tests (self, type):
 
         f = open (log_file)
         log_lines = f.readlines()
         f.close ()
         os.remove (log_file)
 
         self.assertTrue(log_lines > 0, "Something was written to the log file.")
 
+    # Check that lldb truncates its log files
+    def test_log_truncate (self):
+        if (os.path.exists (self.truncate_log_file)):
+            os.remove (self.truncate_log_file)
+
+        # put something in our log file
+        with open(self.truncate_log_file, "w") as f:
+            for i in range(1, 1000):
+                f.write("bacon\n")
+
+        self.runCmd ("log enable -t -f '%s' lldb commands" % (self.truncate_log_file))
+        self.runCmd ("help log")
+        self.runCmd ("log disable lldb")
+
+        self.assertTrue (os.path.isfile (self.truncate_log_file))
+        with open(self.truncate_log_file, "r") as f:
+            contents = f.read ()
+
+        # check that it got removed
+        self.assertTrue(string.find(contents, "bacon") == -1)
+
+    # Check that lldb can append to a log file
+    def test_log_append (self):
+        if (os.path.exists (self.append_log_file)):
+            os.remove (self.append_log_file)
+
+        # put something in our log file
+        with open(self.append_log_file, "w") as f:
+            f.write("bacon\n")
+
+        self.runCmd ("log enable -t -a -f '%s' lldb commands" % (self.append_log_file))
+        self.runCmd ("help log")
+        self.runCmd ("log disable lldb")
+
+        self.assertTrue (os.path.isfile (self.append_log_file))
+        with open(self.append_log_file, "r") as f:
+            contents = f.read ()
+
+        # check that it is still there
+        self.assertTrue(string.find(contents, "bacon") == 0)
+
+
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()