Convert Log class to llvm streams

[labath]

Summary

This converts LLDB's logging to use llvm streams instead of
lldb_private::Stream and friends. The changes are mostly
straight-forward and amount to s/lldb_private::Stream/llvm::raw_ostream.

The part worth calling out is the rewrite of the StreamCallback class.
Previously this class contained a per-thread buffer of data written. I
assume this had something to do with it trying to make sure each log
line is delivered as a single event, instead of multiple (possibly
interleaved) events. However, this is no longer relevant as the Log
class already writes things to a temporary buffer and then delivers the
message as a single "write", so I have just removed the code in
question.

[zturner]

Where is the logging callback used? It seems rather odd that we would need to notify someone every time a log message was generated.

source/Core/StreamCallback.cpp

22 ↗

(On Diff #87349)

I find it rather odd that this was hardcoding big endian. Was the endianness here important for some reason?

[labath]

The log callback gets passed down from the SB API (in the SBDebugger constructor, no less). My best guess is that it is (was?) used to display the debugger log in some IDE window.

source/Core/StreamCallback.cpp

22 ↗

(On Diff #87349)

I think that was there just because you needed to specify some value. As we were always printing strings, it did not matter anyway.

[labath]

Ping. Any thoughts on this?

[clayborg]

Looks good as long as if we type two log enable commands like:

(lldb) log enable -f /tmp/a.txt lldb process
(lldb) log enable -f /tmp/a.txt lldb api

share the same log stream (we don't open /tmp/a.txt twice) if is still open and available.

source/Core/StreamCallback.cpp

22 ↗

(On Diff #87349)

Pavel is correct, this is because streams can be put into binary mode and that you can use Stream::Put32(uint32_t) which will write a number if in non-binary mode, or endian correct bytes if in binary mode. Logs didn't ever use the binary feature so we just set it to defaults.

[labath]

Thank you for the review. I'll submit this tomorrow.

In D29615#670879, @clayborg wrote:

Looks good as long as if we type two log enable commands like:

(lldb) log enable -f /tmp/a.txt lldb process
(lldb) log enable -f /tmp/a.txt lldb api

Yes, the log file still gets shared. I am not changing that.

@zturner:
Aside from the thread stuff, nothing seems particularly risky about this change. Did the thread-local stuff you removed have anything to do with the -t option to the log command?

Well... the thread-safe logging would make that unnecessary, but with the current temporary-buffer implementation you don't need that even without threadsafe logging. This makes be believe the logging callback was written before we had the temporary buffer logic in place, but I haven't dug through the history to verify that.

lldb/trunk/include/lldb/Core/Debugger.h

protected:
   SourceManager::SourceFileCache m_source_file_cache; // All the source managers
                                                       // for targets created in
                                                       // this debugger used this
                                                       // shared
                                                       // source file cache.
   std::unique_ptr<CommandInterpreter> m_command_interpreter_ap;
 
   IOHandlerStack m_input_reader_stack;
-  typedef std::map<std::string, lldb::StreamWP> LogStreamMap;
-  LogStreamMap m_log_streams;
-  lldb::StreamSP m_log_callback_stream_sp;
+  llvm::StringMap<std::weak_ptr<llvm::raw_ostream>> m_log_streams;
+  std::shared_ptr<llvm::raw_ostream> m_log_callback_stream_sp;
   ConstString m_instance_name;
   static LoadPluginCallbackType g_load_plugin_callback;
   typedef std::vector<llvm::sys::DynamicLibrary> LoadedPluginsList;
   LoadedPluginsList m_loaded_plugins;
   HostThread m_event_handler_thread;
   HostThread m_io_handler_thread;
   Broadcaster m_sync_broadcaster;
   lldb::ListenerSP m_forward_listener_sp;

lldb/trunk/include/lldb/Core/Log.h

 
 class Log final {
 public:
   //------------------------------------------------------------------
   // Callback definitions for abstracted plug-in log access.
   //------------------------------------------------------------------
   typedef void (*DisableCallback)(const char **categories,
                                   Stream *feedback_strm);
-  typedef Log *(*EnableCallback)(lldb::StreamSP &log_stream_sp,
-                                 uint32_t log_options, const char **categories,
-                                 Stream *feedback_strm);
+  typedef Log *(*EnableCallback)(
+      const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
+      uint32_t log_options, const char **categories, Stream *feedback_strm);
   typedef void (*ListCategoriesCallback)(Stream *strm);
 
   struct Callbacks {
     DisableCallback disable;
     EnableCallback enable;
     ListCategoriesCallback list_categories;
   };
 
   //------------------------------------------------------------------
   // Static accessors for logging channels
   //------------------------------------------------------------------
   static void RegisterLogChannel(const ConstString &channel,
                                  const Log::Callbacks &log_callbacks);
 
   static bool UnregisterLogChannel(const ConstString &channel);
 
   static bool GetLogChannelCallbacks(const ConstString &channel,
                                      Log::Callbacks &log_callbacks);
 
-  static bool EnableLogChannel(lldb::StreamSP &log_stream_sp,
-                               uint32_t log_options, const char *channel,
-                               const char **categories, Stream &error_stream);
+  static bool
+  EnableLogChannel(const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
 
-  static void EnableAllLogChannels(lldb::StreamSP &log_stream_sp,
-                                   uint32_t log_options,
-                                   const char **categories,
-                                   Stream *feedback_strm);
+  static void
+  EnableAllLogChannels(const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
+                       uint32_t log_options, const char **categories,
 
   static void DisableAllLogChannels(Stream *feedback_strm);
 
   static void ListAllLogChannels(Stream *strm);
 
   static void Initialize();
 
   static void Terminate();
 
   //------------------------------------------------------------------
   // Auto completion
   //------------------------------------------------------------------
   static void AutoCompleteChannelName(const char *channel_name,
                                       StringList &matches);
 
   //------------------------------------------------------------------
   // Member functions
   //------------------------------------------------------------------
   Log();
 
-  Log(const lldb::StreamSP &stream_sp);
+  Log(const std::shared_ptr<llvm::raw_ostream> &stream_sp);
 
   ~Log();
 
   void PutCString(const char *cstr);
   void PutString(llvm::StringRef str);
 
   template <typename... Args>
   void Format(llvm::StringRef file, llvm::StringRef function,
public:
   Flags &GetMask();
 
   const Flags &GetMask() const;
 
   bool GetVerbose() const;
 
   bool GetDebug() const;
 
-  void SetStream(const lldb::StreamSP &stream_sp) { m_stream_sp = stream_sp; }
+  void SetStream(const std::shared_ptr<llvm::raw_ostream> &stream_sp) {
+    m_stream_sp = stream_sp;
+  }
 
 protected:
   //------------------------------------------------------------------
   // Member variables
   //------------------------------------------------------------------
-  lldb::StreamSP m_stream_sp;
+  std::shared_ptr<llvm::raw_ostream> m_stream_sp;
   Flags m_options;
   Flags m_mask_bits;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(Log);
 
   void WriteHeader(llvm::raw_ostream &OS, llvm::StringRef file,
                    llvm::StringRef function);
public:
   ~LogChannel() override;
 
   static lldb::LogChannelSP FindPlugin(const char *plugin_name);
 
   // categories is an array of chars that ends with a NULL element.
   virtual void Disable(const char **categories, Stream *feedback_strm) = 0;
 
   virtual bool
-  Enable(lldb::StreamSP &log_stream_sp, uint32_t log_options,
+  Enable(const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
+         uint32_t log_options,
          Stream *feedback_strm, // Feedback stream for argument errors etc
          const char **categories) = 0; // The categories to enable within this
                                        // logging stream, if empty, enable
                                        // default set
 
   virtual void ListCategories(Stream *strm) = 0;
 
 protected:

lldb/trunk/include/lldb/Core/Logging.h

 //===-- Logging.h -----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Core_Logging_h_
 #define liblldb_Core_Logging_h_
 
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
+// Other libraries and framework includes
+#include "llvm/Support/raw_ostream.h"
 
 //----------------------------------------------------------------------
 // Log Bits specific to logging in lldb
 //----------------------------------------------------------------------
 #define LIBLLDB_LOG_PROCESS (1u << 1)
 #define LIBLLDB_LOG_THREAD (1u << 2)
 #define LIBLLDB_LOG_DYNAMIC_LOADER (1u << 3)
 #define LIBLLDB_LOG_EVENTS (1u << 4)

 Log *GetLogIfAllCategoriesSet(uint32_t mask);
 
 Log *GetLogIfAnyCategoriesSet(uint32_t mask);
 
 uint32_t GetLogMask();
 
 void DisableLog(const char **categories, Stream *feedback_strm);
 
-Log *EnableLog(lldb::StreamSP &log_stream_sp, uint32_t log_options,
-               const char **categories, Stream *feedback_strm);
+Log *EnableLog(const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
+               uint32_t log_options, const char **categories,
+               Stream *feedback_strm);
 
 void ListLogCategories(Stream *strm);
 
 } // namespace lldb_private
 
 #endif // liblldb_Core_Logging_h_

lldb/trunk/include/lldb/Core/StreamCallback.h

 //===-- StreamCallback.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_StreamCallback_h_
 #define liblldb_StreamCallback_h_
 
-#include <mutex>
+#include "lldb/lldb-types.h"
+#include "llvm/Support/raw_ostream.h"
 #include <string>
 
-#include "lldb/Utility/Stream.h"
-#include "lldb/Utility/StreamString.h"
-
 namespace lldb_private {
 
-class StreamCallback : public Stream {
+class StreamCallback : public llvm::raw_ostream {
 public:
   StreamCallback(lldb::LogOutputCallback callback, void *baton);
-
-  ~StreamCallback() override;
-
-  void Flush() override;
-
-  size_t Write(const void *src, size_t src_len) override;
+  ~StreamCallback() override = default;
 
 private:
-  typedef std::map<lldb::tid_t, StreamString> collection;
   lldb::LogOutputCallback m_callback;
   void *m_baton;
-  collection m_accumulated_data;
-  std::mutex m_collection_mutex;
 
-  StreamString &FindStreamForThread(lldb::tid_t cur_tid);
+  void write_impl(const char *Ptr, size_t Size) override;
+  uint64_t current_pos() const override;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_StreamCallback_h

lldb/trunk/source/Core/Debugger.cpp

 // C Includes
 // C++ Includes
 #include <map>
 #include <mutex>
 
 // Other libraries and framework includes
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DynamicLibrary.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 
 // Project includes
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegisterValue.h"
void Debugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
   // open logging streams, I just redirect everything from here on out to the
   // callback.
   m_log_callback_stream_sp.reset(new StreamCallback(log_callback, baton));
 }
 
 bool Debugger::EnableLog(const char *channel, const char **categories,
                          const char *log_file, uint32_t log_options,
                          Stream &error_stream) {
-  StreamSP log_stream_sp;
+  const bool should_close = true;
+  const bool unbuffered = true;
+
+  std::shared_ptr<llvm::raw_ostream> log_stream_sp;
   if (m_log_callback_stream_sp) {
     log_stream_sp = m_log_callback_stream_sp;
     // For now when using the callback mode you always get thread & timestamp.
     log_options |=
         LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
   } else if (log_file == nullptr || *log_file == '\0') {
-    log_stream_sp = GetOutputFile();
+    log_stream_sp = std::make_shared<llvm::raw_fd_ostream>(
+        GetOutputFile()->GetFile().GetDescriptor(), !should_close, unbuffered);
   } else {
-    LogStreamMap::iterator pos = m_log_streams.find(log_file);
+    auto pos = m_log_streams.find(log_file);
     if (pos != m_log_streams.end())
       log_stream_sp = pos->second.lock();
     if (!log_stream_sp) {
-      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));
+      llvm::sys::fs::OpenFlags flags = llvm::sys::fs::F_Text;
+      if (log_options & LLDB_LOG_OPTION_APPEND)
+        flags |= llvm::sys::fs::F_Append;
+      int FD;
+      if (std::error_code ec =
+              llvm::sys::fs::openFileForWrite(log_file, FD, flags)) {
+        error_stream.Format("Unable to open log file: {0}", ec.message());
+        return false;
+      }
+      log_stream_sp.reset(
+          new llvm::raw_fd_ostream(FD, should_close, unbuffered));
       m_log_streams[log_file] = log_stream_sp;
     }
   }
   assert(log_stream_sp);
 
   if (log_options == 0)
     log_options =
         LLDB_LOG_OPTION_PREPEND_THREAD_NAME | LLDB_LOG_OPTION_THREADSAFE;

lldb/trunk/source/Core/Log.cpp

 #include <mutex>
 #include <string>
 
 using namespace lldb;
 using namespace lldb_private;
 
 Log::Log() : m_stream_sp(), m_options(0), m_mask_bits(0) {}
 
-Log::Log(const StreamSP &stream_sp)
+Log::Log(const std::shared_ptr<llvm::raw_ostream> &stream_sp)
     : m_stream_sp(stream_sp), m_options(0), m_mask_bits(0) {}
 
 Log::~Log() = default;
 
 Flags &Log::GetOptions() { return m_options; }
 
 const Flags &Log::GetOptions() const { return m_options; }
 
bool Log::GetLogChannelCallbacks(const ConstString &channel,
   if (pos != callback_map.end()) {
     log_callbacks = pos->second;
     return true;
   }
   ::memset(&log_callbacks, 0, sizeof(log_callbacks));
   return false;
 }
 
-bool Log::EnableLogChannel(lldb::StreamSP &log_stream_sp, uint32_t log_options,
-                           const char *channel, const char **categories,
-                           Stream &error_stream) {
+bool Log::EnableLogChannel(
+    const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
+    uint32_t log_options, const char *channel, const char **categories,
   Log::Callbacks log_callbacks;
   if (Log::GetLogChannelCallbacks(ConstString(channel), log_callbacks)) {
     log_callbacks.enable(log_stream_sp, log_options, categories, &error_stream);
     return true;
   }
 
   LogChannelSP log_channel_sp(LogChannel::FindPlugin(channel));
   if (log_channel_sp) {
     if (log_channel_sp->Enable(log_stream_sp, log_options, &error_stream,
                                categories)) {
       return true;
     } else {
       error_stream.Printf("Invalid log channel '%s'.\n", channel);
       return false;
     }
   } else {
     error_stream.Printf("Invalid log channel '%s'.\n", channel);
     return false;
   }
 }
 
-void Log::EnableAllLogChannels(StreamSP &log_stream_sp, uint32_t log_options,
-                               const char **categories, Stream *feedback_strm) {
+void Log::EnableAllLogChannels(
+    const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
+    uint32_t log_options, const char **categories, Stream *feedback_strm) {
   CallbackMap &callback_map = GetCallbackMap();
   CallbackMapIter pos, end = callback_map.end();
 
   for (pos = callback_map.begin(); pos != end; ++pos)
     pos->second.enable(log_stream_sp, log_options, categories, feedback_strm);
 
   LogChannelMap &channel_map = GetChannelMap();
   LogChannelMapIter channel_pos, channel_end = channel_map.end();
if (m_options.Test(LLDB_LOG_OPTION_PREPEND_FILE_FUNCTION) &&
     function = function.take_front(40);
     OS << llvm::formatv("{0,-60:60} ", (file + ":" + function).str());
   }
 }
 
 void Log::WriteMessage(const std::string &message) {
   // Make a copy of our stream shared pointer in case someone disables our
   // log while we are logging and releases the stream
-  StreamSP stream_sp(m_stream_sp);
+  auto stream_sp = m_stream_sp;
   if (!stream_sp)
     return;
 
   if (m_options.Test(LLDB_LOG_OPTION_THREADSAFE)) {
     static std::recursive_mutex g_LogThreadedMutex;
     std::lock_guard<std::recursive_mutex> guard(g_LogThreadedMutex);
-    stream_sp->PutCString(message.c_str());
-    stream_sp->Flush();
+    *stream_sp << message;
+    stream_sp->flush();
   } else {
-    stream_sp->PutCString(message.c_str());
-    stream_sp->Flush();
+    *stream_sp << message;
+    stream_sp->flush();
   }
 }
 
 void Log::Format(llvm::StringRef file, llvm::StringRef function,
                  const llvm::formatv_object_base &payload) {
   std::string message_string;
   llvm::raw_string_ostream message(message_string);
   WriteHeader(message, file, function);

lldb/trunk/source/Core/Logging.cpp

if (categories && categories[0]) {
                                 arg);
           ListLogCategories(feedback_strm);
           return;
         }
       }
     }
     log->GetMask().Reset(flag_bits);
     if (flag_bits == 0) {
-      log->SetStream(lldb::StreamSP());
+      log->SetStream(nullptr);
       g_log_enabled = false;
     }
   }
 }
 
-Log *lldb_private::EnableLog(StreamSP &log_stream_sp, uint32_t log_options,
-                             const char **categories, Stream *feedback_strm) {
+Log *lldb_private::EnableLog(
+    const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
+    uint32_t log_options, const char **categories, Stream *feedback_strm) {
   // Try see if there already is a log - that way we can reuse its settings.
   // We could reuse the log in toto, but we don't know that the stream is the
   // same.
   uint32_t flag_bits;
   if (g_log != nullptr)
     flag_bits = g_log->GetMask().Get();
   else
     flag_bits = 0;

lldb/trunk/source/Core/StreamCallback.cpp

 //===-- StreamCallback.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include <stdio.h>
-
-#include "lldb/Core/Broadcaster.h"
-#include "lldb/Core/Event.h"
 #include "lldb/Core/StreamCallback.h"
-#include "lldb/Host/Host.h"
-#include "lldb/lldb-private.h"
 
-using namespace lldb;
 using namespace lldb_private;
 
 StreamCallback::StreamCallback(lldb::LogOutputCallback callback, void *baton)
-    : Stream(0, 4, eByteOrderBig), m_callback(callback), m_baton(baton),
-      m_accumulated_data(), m_collection_mutex() {}
-
-StreamCallback::~StreamCallback() {}
-
-StreamString &StreamCallback::FindStreamForThread(lldb::tid_t cur_tid) {
-  std::lock_guard<std::mutex> guard(m_collection_mutex);
-  collection::iterator iter = m_accumulated_data.find(cur_tid);
-  if (iter == m_accumulated_data.end()) {
-    std::pair<collection::iterator, bool> ret;
-    ret = m_accumulated_data.insert(
-        std::pair<lldb::tid_t, StreamString>(cur_tid, StreamString()));
-    iter = ret.first;
-  }
-  return (*iter).second;
-}
+    : llvm::raw_ostream(true), m_callback(callback), m_baton(baton) {}
 
-void StreamCallback::Flush() {
-  lldb::tid_t cur_tid = Host::GetCurrentThreadID();
-  StreamString &out_stream = FindStreamForThread(cur_tid);
-  m_callback(out_stream.GetData(), m_baton);
-  out_stream.Clear();
+void StreamCallback::write_impl(const char *Ptr, size_t Size) {
+  m_callback(std::string(Ptr, Size).c_str(), m_baton);
 }
 
-size_t StreamCallback::Write(const void *s, size_t length) {
-  lldb::tid_t cur_tid = Host::GetCurrentThreadID();
-  FindStreamForThread(cur_tid).Write(s, length);
-  return length;
-}
+uint64_t StreamCallback::current_pos() const { return 0; }

lldb/trunk/source/Plugins/Process/POSIX/ProcessPOSIXLog.h

static void RegisterPluginName(lldb_private::ConstString pluginName) {
     m_pluginname = pluginName.GetCString();
   }
 
   static lldb_private::Log *GetLogIfAllCategoriesSet(uint32_t mask = 0);
 
   static void DisableLog(const char **args,
                          lldb_private::Stream *feedback_strm);
 
-  static lldb_private::Log *EnableLog(lldb::StreamSP &log_stream_sp,
-                                      uint32_t log_options, const char **args,
-                                      lldb_private::Stream *feedback_strm);
+  static lldb_private::Log *
+  EnableLog(const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
 
   static void ListLogCategories(lldb_private::Stream *strm);
 
   static void LogIf(uint32_t mask, const char *format, ...);
 
   // The following functions can be used to enable the client to limit
   // logging to only the top level function calls.  This is useful for
   // recursive functions.  FIXME: not thread safe!

lldb/trunk/source/Plugins/Process/POSIX/ProcessPOSIXLog.cpp

if (log) {
     log->GetMask().Reset(flag_bits);
     if (flag_bits == 0)
       g_log_enabled = false;
   }
 
   return;
 }
 
-Log *ProcessPOSIXLog::EnableLog(StreamSP &log_stream_sp, uint32_t log_options,
-                                const char **args, Stream *feedback_strm) {
+Log *ProcessPOSIXLog::EnableLog(
+    const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
+    uint32_t log_options, const char **args, Stream *feedback_strm) {
   // Try see if there already is a log - that way we can reuse its settings.
   // We could reuse the log in toto, but we don't know that the stream is the
   // same.
   uint32_t flag_bits = 0;
   if (g_log)
     flag_bits = g_log->GetMask().Get();
 
   // Now make a new log with this stream if one was provided

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h

public:
   static void Initialize();
 
   static Log *GetLogIfAllCategoriesSet(uint32_t mask = 0);
 
   static Log *GetLogIfAnyCategoryIsSet(uint32_t mask);
 
   static void DisableLog(const char **categories, Stream *feedback_strm);
 
-  static Log *EnableLog(lldb::StreamSP &log_stream_sp, uint32_t log_options,
-                        const char **categories, Stream *feedback_strm);
+  static Log *EnableLog(const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
+                        uint32_t log_options, const char **categories,
+                        Stream *feedback_strm);
 
   static void ListLogCategories(Stream *strm);
 
   static void LogIf(uint32_t mask, const char *format, ...);
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // liblldb_ProcessGDBRemoteLog_h_

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemoteLog.cpp

if (flag_bits == 0)
       g_log_enabled = false;
     else
       log->GetMask().Reset(flag_bits);
   }
 
   return;
 }
 
-Log *ProcessGDBRemoteLog::EnableLog(StreamSP &log_stream_sp,
-                                    uint32_t log_options,
-                                    const char **categories,
-                                    Stream *feedback_strm) {
+Log *ProcessGDBRemoteLog::EnableLog(
+    const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
+    uint32_t log_options, const char **categories, Stream *feedback_strm) {
   // Try see if there already is a log - that way we can reuse its settings.
   // We could reuse the log in toto, but we don't know that the stream is the
   // same.
   uint32_t flag_bits = 0;
   if (g_log)
     flag_bits = g_log->GetMask().Get();
 
   // Now make a new log with this stream if one was provided

lldb/trunk/source/Plugins/SymbolFile/DWARF/LogChannelDWARF.h

public:
 
   uint32_t GetPluginVersion() override;
 
   void Disable(const char **categories,
                lldb_private::Stream *feedback_strm) override;
 
   void Delete();
 
-  bool Enable(lldb::StreamSP &log_stream_sp, uint32_t log_options,
+  bool Enable(const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
+              uint32_t log_options,
               lldb_private::Stream
                   *feedback_strm, // Feedback stream for argument errors etc
               const char **categories) override; // The categories to enable
                                                  // within this logging stream,
                                                  // if empty, enable default set
 
   void ListCategories(lldb_private::Stream *strm) override;
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/LogChannelDWARF.cpp

if (flag_bits == 0)
     Delete();
   else
     m_log_ap->GetMask().Reset(flag_bits);
 
   return;
 }
 
 bool LogChannelDWARF::Enable(
-    StreamSP &log_stream_sp, uint32_t log_options,
+    const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
+    uint32_t log_options,
     Stream *feedback_strm,  // Feedback stream for argument errors etc
     const char **categories // The categories to enable within this logging
                             // stream, if empty, enable default set
     ) {
   Delete();
 
   if (m_log_ap)
     m_log_ap->SetStream(log_stream_sp);

lldb/trunk/tools/lldb-server/LLDBServerUtilities.cpp

 
 #include "lldb/Core/Log.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FileSystem.h"
 
 using namespace lldb;
 using namespace lldb_private::lldb_server;
 using namespace llvm;
 
+static std::shared_ptr<raw_ostream> GetLogStream(StringRef log_file) {
+  if (!log_file.empty()) {
+    std::error_code EC;
+    std::shared_ptr<raw_ostream> stream_sp = std::make_shared<raw_fd_ostream>(
+        log_file, EC, sys::fs::F_Text | sys::fs::F_Append);
+    if (!EC)
+      return stream_sp;
+    errs() << llvm::formatv(
+        "Failed to open log file `{0}`: {1}\nWill log to stderr instead.\n",
+        log_file, EC.message());
+  }
+  // No need to delete the stderr stream.
+  return std::shared_ptr<raw_ostream>(&errs(), [](raw_ostream *) {});
+}
+
 bool LLDBServerUtilities::SetupLogging(const std::string &log_file,
                                        const StringRef &log_channels,
                                        uint32_t log_options) {
-  lldb::StreamSP log_stream_sp;
-  if (log_file.empty()) {
-    log_stream_sp.reset(new StreamFile(stdout, false));
-  } else {
-    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.c_str(), options));
-  }
+  auto log_stream_sp = GetLogStream(log_file);
 
   SmallVector<StringRef, 32> channel_array;
   log_channels.split(channel_array, ":", /*MaxSplit*/ -1, /*KeepEmpty*/ false);
   for (auto channel_with_categories : channel_array) {
     StreamString error_stream;
     Args channel_then_categories(channel_with_categories);
     std::string channel(channel_then_categories.GetArgumentAtIndex(0));
     channel_then_categories.Shift(); // Shift off the channel

lldb/trunk/unittests/Core/CMakeLists.txt

 add_lldb_unittest(LLDBCoreTests
   ArchSpecTest.cpp
   BroadcasterTest.cpp
   DataExtractorTest.cpp
   ErrorTest.cpp
   ListenerTest.cpp
   LogTest.cpp
   ScalarTest.cpp
   StateTest.cpp
+  StreamCallbackTest.cpp
   StructuredDataTest.cpp
   TimerTest.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
   LINK_COMPONENTS
     Support
   )

lldb/trunk/unittests/Core/LogTest.cpp

 #include "lldb/Host/Host.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static std::string GetLogString(uint32_t log_options, const char *format,
                                 int arg) {
-  std::shared_ptr<StreamString> stream_sp(new StreamString());
+  std::string stream_string;
+  std::shared_ptr<llvm::raw_string_ostream> stream_sp(
+      new llvm::raw_string_ostream(stream_string));
   Log log_(stream_sp);
   log_.GetOptions().Reset(log_options);
   Log *log = &log_;
   LLDB_LOG(log, format, arg);
-  return stream_sp->GetString();
+  return stream_sp->str();
 }
 
 TEST(LogTest, LLDB_LOG_nullptr) {
   Log *log = nullptr;
   LLDB_LOG(log, "{0}", 0); // Shouldn't crash
 }
 
 TEST(LogTest, log_options) {

lldb/trunk/unittests/Core/StreamCallbackTest.cpp

+//===-- StreamCallbackTest.cpp ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/StreamCallback.h"
+#include "gtest/gtest.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+static char test_baton;
+static size_t callback_count = 0;
+static void TestCallback(const char *data, void *baton) {
+  EXPECT_STREQ("Foobar", data);
+  EXPECT_EQ(&test_baton, baton);
+  ++callback_count;
+}
+
+TEST(StreamCallbackTest, Callback) {
+  StreamCallback stream(TestCallback, &test_baton);
+  stream << "Foobar";
+  EXPECT_EQ(1u, callback_count);
+}