Add support for ./dotest.py --channel and --log-success

[vharron]

Summary

New dotest options that allow arbitrary log channels and
categories to be enabled. Also enables logging for locally run
debug servers.

Log messages are separated into separate files per test case.
(this makes it possible to log in dosep runs)

These new log files are stored side-by-side with trace files in the
session directory.

These files are deleted by default if the test run is successful.

If --log-success is specified, even successful logs are retained.

--log-success is useful for creating reference log files.

[vharron]

improved documentation

[vharron]

minor edits

[clayborg]

Looks fine.

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

#endif
         
         const char *env_debugserver_log_file = getenv("LLDB_DEBUGSERVER_LOG_FILE");
         if (env_debugserver_log_file)
         {
             ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-file=%s", env_debugserver_log_file);
             debugserver_args.AppendArgument(arg_cstr);
         }
         
+#if defined(__APPLE__)
         const char *env_debugserver_log_flags = getenv("LLDB_DEBUGSERVER_LOG_FLAGS");
         if (env_debugserver_log_flags)
         {
             ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-flags=%s", env_debugserver_log_flags);
             debugserver_args.AppendArgument(arg_cstr);
         }
+#else
+        const char *env_debugserver_log_channels = getenv("LLDB_SERVER_LOG_CHANNELS");
+        if (env_debugserver_log_channels)
+        {
+            ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-channels=%s", env_debugserver_log_channels);
+            debugserver_args.AppendArgument(arg_cstr);
+        }
+#endif
 
         // Add additional args, starting with LLDB_DEBUGSERVER_EXTRA_ARG_1 until an env var doesn't come back.
         uint32_t env_var_index = 1;
         bool has_env_var;
         do
         {
             char env_var_name[64];
             snprintf (env_var_name, sizeof (env_var_name), "LLDB_DEBUGSERVER_EXTRA_ARG_%" PRIu32, env_var_index++);

lldb/trunk/test/dotest.py

 import progress
 import signal
 import subprocess
 import sys
 import textwrap
 import time
 import inspect
 import unittest2
+import lldbtest_config
 
 if sys.version_info >= (2, 7):
     argparse = __import__('argparse')
 else:
     argparse = __import__('argparse_compat')
 
 def parse_args(parser):
     """ Returns an argument object. LLDB_TEST_ARGUMENTS environment variable can

 
 OK
 
 The 'Session ...' verbiage is recently introduced (see also the '-s' option) to
 notify the directory containing the session logs for test failures or errors.
 In case there is any test failure/error, a similar message is appended at the
 end of the stderr output for your convenience.
 
-Environment variables related to loggings:
+ENABLING LOGS FROM TESTS
+
+Option 1:
+
+Writing logs into different files per test case::
+
+This option is particularly useful when multiple dotest instances are created
+by dosep.py
+
+$ ./dotest.py --channel "lldb all"
+
+$ ./dotest.py --channel "lldb all" --channel "gdb-remote packets"
+
+These log files are written to:
+
+<session-dir>/<test-id>.log (logs from lldb host process)
+<session-dir>/<test-id>-server.log (logs from debugserver/lldb-server)
+<session-dir>/<test-id>-trace-<test-result>.log (console logs)
+
+By default, logs from successful runs are deleted.  Use the --log-success flag
+to create reference logs for debugging.
+
+$ ./dotest.py --log-success
+
+Option 2: (DEPRECATED)
+
+The following options can only enable logs from the host lldb process.
+Only categories from the "lldb" or "gdb-remote" channels can be enabled
+They also do not automatically enable logs in locally running debug servers.
+Also, logs from all test case are written into each log file
 
 o LLDB_LOG: if defined, specifies the log file pathname for the 'lldb' subsystem
   with a default option of 'event process' if LLDB_LOG_OPTION is not defined.
 
 o GDB_REMOTE_LOG: if defined, specifies the log file pathname for the
   'process.gdb-remote' subsystem with a default option of 'packets' if
   GDB_REMOTE_LOG_OPTION is not defined.
 """
def parseOptionsAndInitTestdirs():
     group.add_argument('-e', metavar='benchmark-exe', help='Specify the full path of an executable used for benchmark purposes (see also: -x)')
     group.add_argument('-k', metavar='command', action='append', help="Specify a runhook, which is an lldb command to be executed by the debugger; The option can occur multiple times. The commands are executed one after the other to bring the debugger to a desired state, so that, for example, further benchmarking can be done")
     group.add_argument('-R', metavar='dir', help='Specify a directory to relocate the tests and their intermediate files to. BE WARNED THAT the directory, if exists, will be deleted before running this test driver. No cleanup of intermediate test files is performed in this case')
     group.add_argument('-r', metavar='dir', help="Similar to '-R', except that the directory must not exist before running this test driver")
     group.add_argument('-s', metavar='name', help='Specify the name of the dir created to store the session files of tests with errored or failed status. If not specified, the test driver uses the timestamp as the session dir name')
     group.add_argument('-x', metavar='breakpoint-spec', help='Specify the breakpoint specification for the benchmark executable')
     group.add_argument('-y', type=int, metavar='count', help="Specify the iteration count used to collect our benchmarks. An example is the number of times to do 'thread step-over' to measure stepping speed.")
     group.add_argument('-#', type=int, metavar='sharp', dest='sharp', help='Repeat the test suite for a specified number of times')
+    group.add_argument('--channel', metavar='channel', dest='channels', action='append', help=textwrap.dedent("Specify the log channels (and optional categories) e.g. 'lldb all' or 'gdb-remote packets' if no categories are specified, 'default' is used"))
+    group.add_argument('--log-success', dest='log_success', action='store_true', help="Leave logs/traces even for successful test runs (useful for creating reference log files during debugging.)")
 
     # Configuration options
     group = parser.add_argument_group('Remote platform options')
     group.add_argument('--platform-name', dest='lldb_platform_name', metavar='platform-name', help='The name of a remote platform to use')
     group.add_argument('--platform-url', dest='lldb_platform_url', metavar='platform-url', help='A LLDB platform URL to use when connecting to a remote platform to run the test suite')
     group.add_argument('--platform-working-dir', dest='lldb_platform_working_dir', metavar='platform-working-dir', help='The directory to use on the remote platform.')
 
     # Test-suite behaviour
if args.compilers:
         compilers = args.compilers
     else:
         # Use a compiler appropriate appropriate for the Apple SDK if one was specified
         if platform_system == 'Darwin' and args.apple_sdk:
             compilers = [commands.getoutput('xcrun -sdk "%s" -find clang 2> /dev/null' % (args.apple_sdk))]
         else:
             compilers = ['clang']
 
+    if args.channels:
+        lldbtest_config.channels = args.channels
+
+    if args.log_success:
+        lldbtest_config.log_success = args.log_success
+
     # Set SDKROOT if we are using an Apple SDK
     if platform_system == 'Darwin' and args.apple_sdk:
         os.environ['SDKROOT'] = commands.getoutput('xcrun --sdk "%s" --show-sdk-path 2> /dev/null' % (args.apple_sdk))
 
     if args.archs:
         archs = args.archs
         for arch in archs:
             if arch.startswith('arm') and platform_system == 'Darwin' and not args.apple_sdk:

lldb/trunk/test/lldbtest.py

 ----------------------------------------------------------------------
 Ran 72 tests in 135.468s
 
 OK
 $ 
 """
 
 import abc
+import glob
 import os, sys, traceback
 import os.path
 import re
 import signal
 from subprocess import *
 import StringIO
 import time
 import types
 import unittest2
 import lldb
+import lldbtest_config
 from _pyio import __metaclass__
 
 # See also dotest.parseOptionsAndInitTestdirs(), where the environment variables
 # LLDB_COMMAND_TRACE and LLDB_DO_CLEANUP are set from '-t' and '-r dir' options.
 
 # By default, traceAlways is False.
 if "LLDB_COMMAND_TRACE" in os.environ and os.environ["LLDB_COMMAND_TRACE"]=="YES":
     traceAlways = True
def tearDown(self):
             self.cleanup(dictionary=self.dict)
 
         # In rare cases where there are multiple teardown cleanups added.
         if doCleanup and self.doTearDownCleanups:
             if self.dicts:
                 for dict in reversed(self.dicts):
                     self.cleanup(dictionary=dict)
 
+        self.disableLogChannelsForCurrentTest()
+
         # Decide whether to dump the session info.
         self.dumpSessionInfo()
 
     # =========================================================
     # Various callbacks to allow introspection of test progress
     # =========================================================
 
     def markError(self):
def markUnexpectedSuccess(self, bugnumber):
             # Once by the Python unittest framework, and a second time by us.
             if bugnumber == None:
                 print >> sbuf, "unexpected success"
             else:
                 print >> sbuf, "unexpected success (problem id:" + str(bugnumber) + ")"  
 
     def getRerunArgs(self):
         return " -f %s.%s" % (self.__class__.__name__, self._testMethodName)
-        
+    def getLogBasenameForCurrentTest(self, prefix=None):
+        """
+        returns a partial path that can be used as the beginning of the name of multiple
+        log files pertaining to this test
+
+        <session-dir>/<arch>-<compiler>-<test-file>.<test-class>.<test-method>
+        """
+        dname = os.path.join(os.environ["LLDB_TEST"],
+                     os.environ["LLDB_SESSION_DIRNAME"])
+        if not os.path.isdir(dname):
+            os.mkdir(dname)
+
+        compiler = self.getCompiler()
+
+        if compiler[1] == ':':
+            compiler = compiler[2:]
+
+        fname = "{}-{}-{}".format(self.getArchitecture(), "_".join(compiler.split(os.path.sep)), self.id())
+        if len(fname) > 200:
+            fname = "{}-{}-{}".format(self.getArchitecture(), compiler.split(os.path.sep)[-1], self.id())
+
+        if prefix is not None:
+            fname = "{}-{}".format(prefix, fname)
+
+        return os.path.join(dname, fname)
+
     def dumpSessionInfo(self):
         """
         Dump the debugger interactions leading to a test error/failure.  This
         allows for more convenient postmortem analysis.
 
         See also LLDBTestResult (dotest.py) which is a singlton class derived
         from TextTestResult and overwrites addError, addFailure, and
         addExpectedFailure methods to allow us to to mark the test instance as
         such.
         """
 
         # We are here because self.tearDown() detected that this test instance
         # either errored or failed.  The lldb.test_result singleton contains
         # two lists (erros and failures) which get populated by the unittest
         # framework.  Look over there for stack trace information.
         #
         # The lists contain 2-tuples of TestCase instances and strings holding
         # formatted tracebacks.
         #
         # See http://docs.python.org/library/unittest.html#unittest.TestResult.
+        src_log_basename = self.getLogBasenameForCurrentTest()
+
+        pairs = []
         if self.__errored__:
             pairs = lldb.test_result.errors
             prefix = 'Error'
         elif self.__failed__:
             pairs = lldb.test_result.failures
             prefix = 'Failure'
         elif self.__expected__:
             pairs = lldb.test_result.expectedFailures
             prefix = 'ExpectedFailure'
         elif self.__skipped__:
             prefix = 'SkippedTest'
         elif self.__unexpected__:
             prefix = "UnexpectedSuccess"
         else:
-            # Simply return, there's no session info to dump!
+            prefix = "Success"
+            if not lldbtest_config.log_success:
+                # delete log files, return (don't output trace)
+                for i in glob.glob(src_log_basename + "*"):
+                    os.unlink(i)
                 return
 
+        # rename all log files - prepend with result
+        dst_log_basename = self.getLogBasenameForCurrentTest(prefix)
+        for src in glob.glob(self.getLogBasenameForCurrentTest() + "*"):
+            dst = src.replace(src_log_basename, dst_log_basename)
+            os.rename(src, dst)
+
         if not self.__unexpected__ and not self.__skipped__:
             for test, traceback in pairs:
                 if test is self:
                     print >> self.session, traceback
 
         testMethod = getattr(self, self._testMethodName)
         if getattr(testMethod, "__benchmarks_test__", False):
             benchmarks = True
         else:
             benchmarks = False
 
-        dname = os.path.join(os.environ["LLDB_TEST"],
-                             os.environ["LLDB_SESSION_DIRNAME"])
-        if not os.path.isdir(dname):
-            os.mkdir(dname)
-        compiler = self.getCompiler()
-        if compiler[1] == ':':
-            compiler = compiler[2:]
-
-        fname = "%s-%s-%s-%s.log" % (prefix, self.getArchitecture(), "_".join(compiler.split(os.path.sep)), self.id())
-        if len(fname) > 255:
-            fname = "%s-%s-%s-%s.log" % (prefix, self.getArchitecture(), compiler.split(os.path.sep)[-1], self.id())
-        pname = os.path.join(dname, fname)
+        pname = "{}.log".format(dst_log_basename)
         with open(pname, "w") as f:
             import datetime
             print >> f, "Session info generated @", datetime.datetime.now().ctime()
             print >> f, self.session.getvalue()
             print >> f, "To rerun this test, issue the following command from the 'test' directory:\n"
             print >> f, "./dotest.py %s -v %s %s" % (self.getRunOptions(),
                                                      ('+b' if benchmarks else '-t'),
                                                      self.getRerunArgs())
def getCategories(self):
                         categories_file.close()
                         categories = str.replace(categories,'\n','')
                         categories = str.replace(categories,'\r','')
                         return categories.split(',')
                 else:
                         folder = os.path.dirname(folder)
                         continue
 
+    def enableLogChannelsForCurrentTest(self):
+        if len(lldbtest_config.channels) == 0:
+            return
+
+        # if debug channels are specified in lldbtest_config.channels,
+        # create a new set of log files for every test
+        log_basename = self.getLogBasenameForCurrentTest()
+
+        # confirm that the file is writeable
+        host_log_path = "{}-host.log".format(log_basename)
+        open(host_log_path, 'w').close()
+
+        log_enable = "log enable -Tpn -f {} ".format(host_log_path)
+        for channel_with_categories in lldbtest_config.channels:
+            channel_then_categories = channel_with_categories.split(' ', 1)
+            channel = channel_then_categories[0]
+            if len(channel_then_categories) > 1:
+                categories = channel_then_categories[1]
+            else:
+                categories = "default"
+
+            if channel == "gdb-remote":
+                # communicate gdb-remote categories to debugserver
+                os.environ["LLDB_DEBUGSERVER_LOG_FLAGS"] = categories
+
+            self.ci.HandleCommand(log_enable + channel_with_categories, self.res)
+            if not self.res.Succeeded():
+                raise Exception('log enable failed (check LLDB_LOG_OPTION env variable)')
+
+        # Communicate log path name to debugserver & lldb-server
+        server_log_path = "{}-server.log".format(log_basename)
+        open(server_log_path, 'w').close()
+        os.environ["LLDB_DEBUGSERVER_LOG_FILE"] = server_log_path
+
+        # Communicate channels to lldb-server
+        os.environ["LLDB_SERVER_LOG_CHANNELS"] = ":".join(lldbtest_config.channels)
+
+        if len(lldbtest_config.channels) == 0:
+            return
+
+    def disableLogChannelsForCurrentTest(self):
+        # close all log files that we opened
+        for channel_and_categories in lldbtest_config.channels:
+            # channel format - <channel-name> [<category0> [<category1> ...]]
+            channel = channel_and_categories.split(' ', 1)[0]
+            self.ci.HandleCommand("log disable " + channel, self.res)
+            if not self.res.Succeeded():
+                raise Exception('log disable failed (check LLDB_LOG_OPTION env variable)')
+
     def setUp(self):
         #import traceback
         #traceback.print_stack()
 
         # Works with the test driver to conditionally skip tests via decorators.
         Base.setUp(self)
 
         try:
def setUp(self):
         try:
             self.dbg = lldb.DBG
         except AttributeError:
             self.dbg = lldb.SBDebugger.Create()
 
         if not self.dbg:
             raise Exception('Invalid debugger instance')
 
+        # Retrieve the associated command interpreter instance.
+        self.ci = self.dbg.GetCommandInterpreter()
+        if not self.ci:
+            raise Exception('Could not get the command interpreter')
+
+        # And the result object.
+        self.res = lldb.SBCommandReturnObject()
+
+        # Create the debugger instance if necessary.
+        try:
+            self.dbg = lldb.DBG
+        except AttributeError:
+            self.dbg = lldb.SBDebugger.Create()
+
+        if not self.dbg:
+            raise Exception('Invalid debugger instance')
+
+        # Retrieve the associated command interpreter instance.
+        self.ci = self.dbg.GetCommandInterpreter()
+        if not self.ci:
+            raise Exception('Could not get the command interpreter')
+
+        # And the result object.
+        self.res = lldb.SBCommandReturnObject()
+
+        self.enableLogChannelsForCurrentTest()
+
         #
         # Warning: MAJOR HACK AHEAD!
         # If we are running testsuite remotely (by checking lldb.lldbtest_remote_sandbox),
         # redefine the self.dbg.CreateTarget(filename) method to execute a "file filename"
         # command, instead.  See also runCmd() where it decorates the "file filename" call
         # with additional functionality when running testsuite remotely.
         #
         if lldb.lldbtest_remote_sandbox:

lldb/trunk/test/lldbtest_config.py

+"""
+                     The LLVM Compiler Infrastructure
+
+ This file is distributed under the University of Illinois Open Source
+ License. See LICENSE.TXT for details.
+
+Configuration options for lldbtest.py set by dotest.py during initialization
+"""
+
+# array of strings
+# each string has the name of an lldb channel followed by
+# zero or more categories in that channel
+# ex. "gdb-remote packets"
+channels = []
+
+# leave logs/traces even for successful test runs
+log_success = False

lldb/trunk/tools/lldb-server/CMakeLists.txt

 set(LLVM_NO_RTTI 1)
 
 if ( CMAKE_SYSTEM_NAME MATCHES "Linux" )
 include_directories(
+  ../../../../llvm/include
   ../../source/Plugins/Process/Linux
   ../../source/Plugins/Process/POSIX
   )
 endif ()
 
 if ( CMAKE_SYSTEM_NAME MATCHES "FreeBSD" )
 include_directories(
+  ../../../../llvm/include
   ../../source/Plugins/Process/FreeBSD
   ../../source/Plugins/Process/POSIX
   )
 endif ()
 
 include_directories(../../source)
 
 include(../../cmake/LLDBDependencies.cmake)

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

 #ifndef _WIN32
 #include <signal.h>
 #include <unistd.h>
 #endif
 
 // C++ Includes
 
 // Other libraries and framework includes
+#include "llvm/ADT/StringRef.h"
+
 #include "lldb/Core/Error.h"
 #include "lldb/Core/ConnectionMachPort.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Pipe.h"

 #ifndef LLGS_PROGRAM_NAME
 #define LLGS_PROGRAM_NAME "lldb-server"
 #endif
 
 #ifndef LLGS_VERSION_STR
 #define LLGS_VERSION_STR "local_build"
 #endif
 
+using namespace llvm;
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
 
 // lldb-gdbserver state
 
 namespace
 {

 static int g_debug = 0;
 static int g_verbose = 0;
 
 static struct option g_long_options[] =
 {
     { "debug",              no_argument,        &g_debug,           1   },
     { "platform",           required_argument,  NULL,               'p' },
     { "verbose",            no_argument,        &g_verbose,         1   },
-    { "lldb-command",       required_argument,  NULL,               'c' },
     { "log-file",           required_argument,  NULL,               'l' },
-    { "log-flags",          required_argument,  NULL,               'f' },
+    { "log-channels",       required_argument,  NULL,               'c' },
     { "attach",             required_argument,  NULL,               'a' },
     { "named-pipe",         required_argument,  NULL,               'N' },
     { "pipe",               required_argument,  NULL,               'U' },
     { "native-regs",        no_argument,        NULL,               'r' },  // Specify to use the native registers instead of the gdb defaults for the architecture.  NOTE: this is a do-nothing arg as it's behavior is default now.  FIXME remove call from lldb-platform.
     { "reverse-connect",    no_argument,        NULL,               'R' },  // Specifies that llgs attaches to the client address:port rather than llgs listening for a connection from address on port.
     { "setsid",             no_argument,        NULL,               'S' },  // Call setsid() to make llgs run in its own session.
     { NULL,                 0,                  NULL,               0   }
 };
dump_available_platforms (FILE *output_file)
     {
         // add this since the default platform doesn't necessarily get registered by
         // the plugin name (e.g. 'host' doesn't show up as a
         // registered platform plugin even though it's the default).
         fprintf (output_file, "%s\tDefault platform for this host.\n", Platform::GetHostPlatform ()->GetPluginName ().AsCString ());
     }
 }
 
-static void
-run_lldb_commands (const lldb::DebuggerSP &debugger_sp, const std::vector<std::string> &lldb_commands)
-{
-    for (const auto &lldb_command : lldb_commands)
-    {
-        printf("(lldb) %s\n", lldb_command.c_str ());
-
-        lldb_private::CommandReturnObject result;
-        debugger_sp->GetCommandInterpreter ().HandleCommand (lldb_command.c_str (), eLazyBoolNo, result);
-        const char *output = result.GetOutputData ();
-        if (output && output[0])
-            puts (output);
-    }
-}
-
 static lldb::PlatformSP
 setup_platform (const std::string &platform_name)
 {
     lldb::PlatformSP platform_sp;
 
     if (platform_name.empty())
     {
         printf ("using the default platform: ");
#ifdef __linux__
     pthread_sigmask(SIG_BLOCK, &set, NULL);
 #endif
 
     const char *progname = argv[0];
     const char *subcommand = argv[1];
     argc--;
     argv++;
     int long_option_index = 0;
-    StreamSP log_stream_sp;
     Args log_args;
     Error error;
     int ch;
     std::string platform_name;
     std::string attach_target;
     std::string named_pipe_path;
+    std::string log_file;
+    StringRef log_channels; // e.g. "lldb process threads:gdb-remote default:linux all"
     int unnamed_pipe_fd = -1;
     bool reverse_connect = false;
 
     lldb::DebuggerSP debugger_sp = Debugger::CreateInstance ();
 
     debugger_sp->SetInputFileHandle(stdin, false);
     debugger_sp->SetOutputFileHandle(stdout, false);
     debugger_sp->SetErrorFileHandle(stderr, false);
#endif
     {
         switch (ch)
         {
         case 0:   // Any optional that auto set themselves will return 0
             break;
 
         case 'l': // Set Log File
             if (optarg && optarg[0])
-            {
-                if ((strcasecmp(optarg, "stdout") == 0) || (strcmp(optarg, "/dev/stdout") == 0))
-                {
-                    log_stream_sp.reset (new StreamFile (stdout, false));
-                }
-                else if ((strcasecmp(optarg, "stderr") == 0) || (strcmp(optarg, "/dev/stderr") == 0))
-                {
-                    log_stream_sp.reset (new StreamFile (stderr, false));
-                }
-                else
-                {
-                    FILE *log_file = fopen(optarg, "w");
-                    if (log_file)
-                    {
-                        setlinebuf(log_file);
-                        log_stream_sp.reset (new StreamFile (log_file, true));
-                    }
-                    else
-                    {
-                        const char *errno_str = strerror(errno);
-                        fprintf (stderr, "Failed to open log file '%s' for writing: errno = %i (%s)", optarg, errno, errno_str ? errno_str : "unknown error");
-                    }
-
-                }
-            }
+                log_file.assign(optarg);
             break;
 
-        case 'f': // Log Flags
+        case 'c': // Log Channels
             if (optarg && optarg[0])
-                log_args.AppendArgument(optarg);
-            break;
-
-        case 'c': // lldb commands
-            if (optarg && optarg[0])
-                lldb_commands.push_back(optarg);
+                log_channels = StringRef(optarg);
             break;
 
         case 'p': // platform name
             if (optarg && optarg[0])
                 platform_name = optarg;
             break;
 
         case 'N': // named pipe
#endif
     }
 
     if (show_usage || option_error)
     {
         display_usage(progname, subcommand);
         exit(option_error);
     }
 
-    if (log_stream_sp)
-    {
-        if (log_args.GetArgumentCount() == 0)
-            log_args.AppendArgument("default");
-        ProcessGDBRemoteLog::EnableLog (log_stream_sp, 0,log_args.GetConstArgumentVector(), log_stream_sp.get());
+    SmallVector<StringRef, 32> channel_array;
+    log_channels.split(channel_array, ":");
+    uint32_t log_options = 0;
+    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
+        bool success = debugger_sp->EnableLog (channel.c_str(),
+                                               channel_then_categories.GetConstArgumentVector(),
+                                               log_file.c_str(),
+                                               log_options,
+                                               error_stream);
+        if (!success)
+        {
+            fprintf(stderr, "Unable to open log file '%s' for channel \"%s\"",
+                    log_file.c_str(),
+                    channel_with_categories.str().c_str());
+            return -1;
         }
+    }
+
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (GDBR_LOG_VERBOSE));
     if (log)
     {
         log->Printf ("lldb-server launch");
         for (int i = 0; i < argc; i++)
         {
             log->Printf ("argv[%i] = '%s'", i, argv[i]);
         }
     }
 
     // Skip any options we consumed with getopt_long_only.
     argc -= optind;
     argv += optind;
 
     if (argc == 0)
     {
         display_usage(progname, subcommand);
         exit(255);
     }
 
-    // Run any commands requested.
-    run_lldb_commands (debugger_sp, lldb_commands);
-
     // Setup the platform that GDBRemoteCommunicationServerLLGS will use.
     lldb::PlatformSP platform_sp = setup_platform (platform_name);
 
     GDBRemoteCommunicationServerLLGS gdb_server (platform_sp, debugger_sp);
 
     const char *const host_and_port = argv[0];
     argc -= 1;
     argv += 1;