remote-gdb-server platform able to run processes on a remote system

[vharron]

Summary

This patch gets remote-gdb-server platform able to run processes on a remote system

1. Make sure the selected platform is always used
2. Make sure that the host uses the connect://hostname to connect to both the lldb-platform and the lldb-gdbserver rather than what the platform reports as the hostname of the lldb-gdbserver
3. Make sure that lldb-platform uses the IP address on it's connection back to the host instead of the hostname that the host sends to it when launching lldb-gdbserver with the remote host information

Details:

source/Commands/CommandObjectPlatform.cpp
added SetSelectedPlatform call, because this is what SB does
source/Commands/CommandObjectTarget.cpp
removed m_platform_options - why was it ever in target?
calling CreateTarget with the selected platform (remote-gdb-server) instead of using m_platform_options, which was creating and using a new "host" platform instead of whatever is selected
source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp
implemented PlatformRemoteGDBServer::ResolveExecutable, mostly copied from iOS version
added primitive PlatformRemoteGDBServer::GetSupportedArchitectureAtIndex implementation
PlatformRemoteGDBServer::ConnectRemote - retaining hostname where lldb-platform is running so we can re-use it when we connect to the gdb server.
source/Target/Platform.cpp
implemented Platform::PutFile
source/Target/TargetList.cpp
make sure we're using a platform if one is selected

[ovyalov]

source/Target/Platform.cpp

1272

Do we need to check for error here?

1274

ditto.

[clayborg]

See inline command about checking "bytes_written" for zero. Fix that and it is good to go.

source/Target/Platform.cpp

1274

We need to check for "bytes_written" being zero and break out if it is zero otherwise we will spin for ever here.

[vharron]

Refactored PlatformPOSIX::PutFile, removed duplicated code

Platform::PutFile
Added error check after WriteFile, reformatted

[vharron]

Updated to address comments, committed back in r226712

source/Commands/CommandObjectPlatform.cpp

DoExecute (Args& args, CommandReturnObject &result)
             {
                 const bool select = true;
                 m_platform_options.SetPlatformName (platform_name);
                 Error error;
                 ArchSpec platform_arch;
                 PlatformSP platform_sp (m_platform_options.CreatePlatformWithOptions (m_interpreter, ArchSpec(), select, error, platform_arch));
                 if (platform_sp)
                 {
+                    m_interpreter.GetDebugger().GetPlatformList().SetSelectedPlatform(platform_sp);
+
                     platform_sp->GetStatus (result.GetOutputStream());
                     result.SetStatus (eReturnStatusSuccessFinishResult);
                 }
                 else
                 {
                     result.AppendError(error.AsCString());
                     result.SetStatus (eReturnStatusFailed);
                 }

source/Commands/CommandObjectTarget.cpp

 public:
     CommandObjectTargetCreate(CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "target create",
                              "Create a target using the argument as the main executable.",
                              NULL),
         m_option_group (interpreter),
         m_arch_option (),
-        m_platform_options(true), // Do include the "--platform" option in the platform settings by passing true
         m_core_file (LLDB_OPT_SET_1, false, "core", 'c', 0, eArgTypeFilename, "Fullpath to a core file to use for this target."),
         m_platform_path (LLDB_OPT_SET_1, false, "platform-path", 'P', 0, eArgTypePath, "Path to the remote file to use for this target."),
         m_symbol_file (LLDB_OPT_SET_1, false, "symfile", 's', 0, eArgTypeFilename, "Fullpath to a stand alone debug symbols file for when debug symbols are not in the executable."),
         m_remote_file (LLDB_OPT_SET_1, false, "remote-file", 'r', 0, eArgTypeFilename, "Fullpath to the file on the remote host if debugging remotely."),
         m_add_dependents (LLDB_OPT_SET_1, false, "no-dependents", 'd', "Don't load dependent files when creating the target, just add the specified executable.", true, true)
     {
         CommandArgumentEntry arg;
         CommandArgumentData file_arg;
 
         // Define the first (and only) variant of this arg.
             file_arg.arg_type = eArgTypeFilename;
         file_arg.arg_repetition = eArgRepeatPlain;
 
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (file_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
 
         m_option_group.Append (&m_arch_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
-        m_option_group.Append (&m_platform_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_core_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_platform_path, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_symbol_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_remote_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_add_dependents, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Finalize();
     }
 
DoExecute (Args& command, CommandReturnObject &result)
                         result.SetStatus (eReturnStatusFailed);
                         return false;
                     }
                 }
             }
 
             TargetSP target_sp;
             const char *arch_cstr = m_arch_option.GetArchitectureName();
+            ArchSpec arch_spec(arch_cstr);
             const bool get_dependent_files = m_add_dependents.GetOptionValue().GetCurrentValue();
             Error error (debugger.GetTargetList().CreateTarget (debugger,
-//                                                                remote_file ? remote_file : file_spec,
                                                                 file_path,
-                                                                arch_cstr,
+                                                                arch_spec,
                                                                 get_dependent_files,
-                                                                &m_platform_options,
+                                                                platform_sp,
                                                                 target_sp));
 
             if (target_sp)
             {
                 if (symfile || remote_file)
                 {
                     ModuleSP module_sp (target_sp->GetExecutableModule());
                     if (module_sp)
DoExecute (Args& command, CommandReturnObject &result)
             result.SetStatus (eReturnStatusFailed);
         }
         return result.Succeeded();
     }
 
 private:
     OptionGroupOptions m_option_group;
     OptionGroupArchitecture m_arch_option;
-    OptionGroupPlatform m_platform_options;
     OptionGroupFile m_core_file;
     OptionGroupFile m_platform_path;
     OptionGroupFile m_symbol_file;
     OptionGroupFile m_remote_file;
     OptionGroupBoolean m_add_dependents;
 };
 
 #pragma mark CommandObjectTargetList

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

else if (m_remote_platform_sp)
             {
                 // Don't chown a local file for a remote system
 //                if (chown_file(this,dst_path.c_str(),uid,gid) != 0)
 //                    return Error("unable to perform chown");
                 return Error();
             }
             // if we are still here rsync has failed - let's try the slow way before giving up
         }
-        
-        if (log)
-            log->Printf ("PlatformPOSIX::PutFile(src='%s', dst='%s', uid=%u, gid=%u)",
-                         source.GetPath().c_str(),
-                         destination.GetPath().c_str(),
-                         uid,
-                         gid); // REMOVE THIS PRINTF PRIOR TO CHECKIN
-        // open
-        // read, write, read, write, ...
-        // close
-        // chown uid:gid dst
-        if (log)
-            log->Printf("[PutFile] Using block by block transfer....\n");
-        
-        uint32_t source_open_options = File::eOpenOptionRead;
-        if (source.GetFileType() == FileSpec::eFileTypeSymbolicLink)
-            source_open_options |= File::eOpenoptionDontFollowSymlinks;
-
-        File source_file(source, source_open_options, lldb::eFilePermissionsUserRW);
-        Error error;
-        uint32_t permissions = source_file.GetPermissions(error);
-        if (permissions == 0)
-            permissions = lldb::eFilePermissionsFileDefault;
-
-        if (!source_file.IsValid())
-            return Error("unable to open source file");
-        lldb::user_id_t dest_file = OpenFile (destination,
-                                              File::eOpenOptionCanCreate | File::eOpenOptionWrite | File::eOpenOptionTruncate,
-                                              permissions,
-                                              error);
-        if (log)
-            log->Printf ("dest_file = %" PRIu64 "\n", dest_file);
-        if (error.Fail())
-            return error;
-        if (dest_file == UINT64_MAX)
-            return Error("unable to open target file");
-        lldb::DataBufferSP buffer_sp(new DataBufferHeap(1024, 0));
-        uint64_t offset = 0;
-        while (error.Success())
-        {
-            size_t bytes_read = buffer_sp->GetByteSize();
-            error = source_file.Read(buffer_sp->GetBytes(), bytes_read);
-            if (bytes_read)
-            {
-                const uint64_t bytes_written = WriteFile(dest_file, offset, buffer_sp->GetBytes(), bytes_read, error);
-                offset += bytes_written;
-                if (bytes_written != bytes_read)
-                {
-                    // We didn't write the correct numbe of bytes, so adjust
-                    // the file position in the source file we are reading from...
-                    source_file.SeekFromStart(offset);
-                }
-            }
-            else
-                break;
-        }
-        CloseFile(dest_file, error);
-        if (uid == UINT32_MAX && gid == UINT32_MAX)
-            return error;
-        // This is remopve, don't chown a local file...
-//        std::string dst_path (destination.GetPath());
-//        if (chown_file(this,dst_path.c_str(),uid,gid) != 0)
-//            return Error("unable to perform chown");
-
-
-        uint64_t src_md5[2];
-        uint64_t dst_md5[2];
-
-        if (FileSystem::CalculateMD5 (source, src_md5[0], src_md5[1]) && CalculateMD5 (destination, dst_md5[0], dst_md5[1]))
-        {
-            if (src_md5[0] != dst_md5[0] || src_md5[1] != dst_md5[1])
-            {
-                error.SetErrorString("md5 checksum of installed file doesn't match, installation failed");
-            }
-        }
-        return error;
     }
     return Platform::PutFile(source,destination,uid,gid);
 }
 
 lldb::user_id_t
 PlatformPOSIX::GetFileSize (const FileSpec& file_spec)
 {
     if (IsHost())

source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h

RunShellCommand (const char *command,           // Shouldn't be NULL
                      uint32_t timeout_sec);         // Timeout in seconds to wait for shell program to finish
 
     virtual void
     CalculateTrapHandlerSymbolNames ();
 
 protected:
     GDBRemoteCommunicationClient m_gdb_client;
     std::string m_platform_description; // After we connect we can get a more complete description of what we are connected to
+    std::string m_platform_hostname;
 
 private:
     DISALLOW_COPY_AND_ASSIGN (PlatformRemoteGDBServer);
 
 };
 
 #endif  // liblldb_PlatformRemoteGDBServer_h_

source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
+#include "Utility/UriParser.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 static bool g_initialized = false;
 
 void
 PlatformRemoteGDBServer::Initialize ()
 {
PlatformRemoteGDBServer::GetDescription ()
     return GetDescriptionStatic();
 }
 
 Error
 PlatformRemoteGDBServer::ResolveExecutable (const ModuleSpec &module_spec,
                                             lldb::ModuleSP &exe_module_sp,
                                             const FileSpecList *module_search_paths_ptr)
 {
+    // copied from PlatformRemoteiOS
+
     Error error;
-    //error.SetErrorString ("PlatformRemoteGDBServer::ResolveExecutable() is unimplemented");
-    if (m_gdb_client.GetFileExists(module_spec.GetFileSpec()))
+    // Nothing special to do here, just use the actual file and architecture
+
+    ModuleSpec resolved_module_spec(module_spec);
+
+    // Resolve any executable within an apk on Android?
+    //Host::ResolveExecutableInBundle (resolved_module_spec.GetFileSpec());
+
+    if (resolved_module_spec.GetFileSpec().Exists())
+    {
+        if (resolved_module_spec.GetArchitecture().IsValid() || resolved_module_spec.GetUUID().IsValid())
+        {
+            error = ModuleList::GetSharedModule (resolved_module_spec,
+                                                 exe_module_sp,
+                                                 NULL,
+                                                 NULL,
+                                                 NULL);
+
+            if (exe_module_sp && exe_module_sp->GetObjectFile())
                 return error;
-    // TODO: get the remote end to somehow resolve this file
-    error.SetErrorString("file not found on remote end");
+            exe_module_sp.reset();
+        }
+        // No valid architecture was specified or the exact arch wasn't
+        // found so ask the platform for the architectures that we should be
+        // using (in the correct order) and see if we can find a match that way
+        StreamString arch_names;
+        for (uint32_t idx = 0; GetSupportedArchitectureAtIndex (idx, resolved_module_spec.GetArchitecture()); ++idx)
+        {
+            error = ModuleList::GetSharedModule (resolved_module_spec,
+                                                 exe_module_sp,
+                                                 NULL,
+                                                 NULL,
+                                                 NULL);
+            // Did we find an executable using one of the
+            if (error.Success())
+            {
+                if (exe_module_sp && exe_module_sp->GetObjectFile())
+                    break;
+                else
+                    error.SetErrorToGenericError();
+            }
+
+            if (idx > 0)
+                arch_names.PutCString (", ");
+            arch_names.PutCString (resolved_module_spec.GetArchitecture().GetArchitectureName());
+        }
+
+        if (error.Fail() || !exe_module_sp)
+        {
+            if (resolved_module_spec.GetFileSpec().Readable())
+            {
+                error.SetErrorStringWithFormat ("'%s' doesn't contain any '%s' platform architectures: %s",
+                                                resolved_module_spec.GetFileSpec().GetPath().c_str(),
+                                                GetPluginName().GetCString(),
+                                                arch_names.GetString().c_str());
+            }
+            else
+            {
+                error.SetErrorStringWithFormat("'%s' is not readable", resolved_module_spec.GetFileSpec().GetPath().c_str());
+            }
+        }
+    }
+    else
+    {
+        error.SetErrorStringWithFormat ("'%s' does not exist",
+                                        resolved_module_spec.GetFileSpec().GetPath().c_str());
+    }
+
     return error;
 }
 
 Error
 PlatformRemoteGDBServer::GetFileWithUUID (const FileSpec &platform_file, 
                                           const UUID *uuid_ptr,
                                           FileSpec &local_file)
 {

 //------------------------------------------------------------------
 PlatformRemoteGDBServer::~PlatformRemoteGDBServer()
 {
 }
 
 bool
 PlatformRemoteGDBServer::GetSupportedArchitectureAtIndex (uint32_t idx, ArchSpec &arch)
 {
+    ArchSpec remote_arch = m_gdb_client.GetSystemArchitecture();
+
+    // TODO: 64 bit systems should also advertize support for 32 bit arch
+    // unknown CPU, we just support the one arch
+    if (idx == 0)
+    {
+        arch = remote_arch;
+        return true;
+    }
     return false;
 }
 
 size_t
 PlatformRemoteGDBServer::GetSoftwareBreakpointTrapOpcode (Target &target, BreakpointSite *bp_site)
 {
     // This isn't needed if the z/Z packets are supported in the GDB remote
     // server. But we might need a packet to detect this.
if (IsConnected())
                                         GetHostname());
     }
     else
     {
         if (args.GetArgumentCount() == 1)
         {
             const char *url = args.GetArgumentAtIndex(0);
             m_gdb_client.SetConnection (new ConnectionFileDescriptor());
+
+            // we're going to reuse the hostname when we connect to the debugserver
+            std::string scheme;
+            int port;
+            std::string path;
+            if ( !UriParser::Parse(url, scheme, m_platform_hostname, port, path) )
+            {
+                error.SetErrorString("invalid uri");
+                return error;
+            }
+
             const ConnectionStatus status = m_gdb_client.Connect(url, &error);
             if (status == eConnectionStatusSuccess)
             {
                 if (m_gdb_client.HandshakeWithServer(&error))
                 {
                     m_gdb_client.GetHostInfo();
                     // If a working directory was set prior to connecting, send it down now
                     if (m_working_dir)
if (IsRemote())
                     {
                         char connect_url[256];
                         const char *override_hostname = getenv("LLDB_PLATFORM_REMOTE_GDB_SERVER_HOSTNAME");
                         const char *port_offset_c_str = getenv("LLDB_PLATFORM_REMOTE_GDB_SERVER_PORT_OFFSET");
                         int port_offset = port_offset_c_str ? ::atoi(port_offset_c_str) : 0;
                         const int connect_url_len = ::snprintf (connect_url,
                                                                 sizeof(connect_url),
                                                                 "connect://%s:%u",
-                                                                override_hostname ? override_hostname : GetHostname (),
+                                                                override_hostname ? override_hostname : m_platform_hostname.c_str(),
                                                                 port + port_offset);
                         assert (connect_url_len < (int)sizeof(connect_url));
                         error = process_sp->ConnectRemote (NULL, connect_url);
                         // Retry the connect remote one time...
                         if (error.Fail())
                             error = process_sp->ConnectRemote (NULL, connect_url);
                         if (error.Success())
                             error = process_sp->Launch(launch_info);
if (IsRemote())
                     {
                         char connect_url[256];
                         const char *override_hostname = getenv("LLDB_PLATFORM_REMOTE_GDB_SERVER_HOSTNAME");
                         const char *port_offset_c_str = getenv("LLDB_PLATFORM_REMOTE_GDB_SERVER_PORT_OFFSET");
                         int port_offset = port_offset_c_str ? ::atoi(port_offset_c_str) : 0;
                         const int connect_url_len = ::snprintf (connect_url, 
                                                                 sizeof(connect_url), 
                                                                 "connect://%s:%u", 
-                                                                override_hostname ? override_hostname : GetHostname (), 
+                                                                override_hostname ? override_hostname : m_platform_hostname.c_str(),
                                                                 port + port_offset);
                         assert (connect_url_len < (int)sizeof(connect_url));
                         error = process_sp->ConnectRemote (NULL, connect_url);
                         if (error.Success())
                             error = process_sp->Attach(attach_info);
                         else if (debugserver_pid != LLDB_INVALID_PROCESS_ID)
                         {
                             m_gdb_client.KillSpawnedProcess(debugserver_pid);

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h

#endif
 
     bool
     JoinListenThread ();
 
     static lldb::thread_result_t
     ListenThread (lldb::thread_arg_t arg);
 
 private:
     lldb_private::HostThread m_listen_thread;
     std::string m_listen_url;
-    
-
     //------------------------------------------------------------------
     // For GDBRemoteCommunication only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (GDBRemoteCommunication);
 };
 
 #endif  // liblldb_GDBRemoteCommunication_h_

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

else
         {
             // Make the GDB server we launch accept connections from any host since we can't figure out the hostname
             stream.Printf("host:*;");
         }
     }
     const char *packet = stream.GetData();
     int packet_len = stream.GetSize();
 
-    if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
+    // give the process a few seconds to startup
+    const uint32_t old_packet_timeout = SetPacketTimeout (10);
+    auto result = SendPacketAndWaitForResponse(packet, packet_len, response, false);
+    SetPacketTimeout (old_packet_timeout);
+    if (result == PacketResult::Success)
     {
         std::string name;
         std::string value;
         uint16_t port = 0;
         while (response.GetNameColonValue(name, value))
         {
             if (name.compare("port") == 0)
                 port = StringConvert::ToUInt32(value.c_str(), 0, 0);

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.cpp

 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/NativeRegisterContext.h"
 #include "Host/common/NativeProcessProtocol.h"
 #include "Host/common/NativeThreadProtocol.h"
 
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
+#include "Utility/UriParser.h"
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // GDBRemote Errors
if (m_is_platform)
                 port = StringConvert::ToUInt32(value.c_str(), 0, 0);
         }
         if (port == UINT16_MAX)
             port = GetNextAvailablePort();
 
         // Spawn a new thread to accept the port that gets bound after
         // binding to port 0 (zero).
 
+        // ignore the hostname send from the remote end, just use the ip address
+        // that we're currently communicating with as the hostname
+
         // Spawn a debugserver and try to get the port it listens to.
         ProcessLaunchInfo debugserver_launch_info;
         if (hostname.empty())
             hostname = "127.0.0.1";
         if (log)
             log->Printf("Launching debugserver with: %s:%u...\n", hostname.c_str(), port);
 
         debugserver_launch_info.SetMonitorProcessCallback(ReapDebugserverProcess, this, false);
 
-        Error error = StartDebugserverProcess (hostname.empty() ? NULL : hostname.c_str(),
+        std::string platform_scheme;
+        std::string platform_ip;
+        int platform_port;
+        std::string platform_path;
+        bool ok = UriParser::Parse(GetConnection()->GetURI().c_str(), platform_scheme, platform_ip, platform_port, platform_path);
+        assert(ok);
+        Error error = StartDebugserverProcess (
+                                         platform_ip.c_str(),
                                          port,
                                          debugserver_launch_info,
                                          port);
 
         lldb::pid_t debugserver_pid = debugserver_launch_info.GetProcessID();
 
 
         if (debugserver_pid != LLDB_INVALID_PROCESS_ID)

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 }
 
 
 Error
 ProcessGDBRemote::ConnectToDebugserver (const char *connect_url)
 {
     Error error;
     // Only connect if we have a valid connect URL
+    Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
     
     if (connect_url && connect_url[0])
     {
+        if (log)
+            log->Printf("ProcessGDBRemote::%s Connecting to %s", __FUNCTION__, connect_url);
         std::unique_ptr<ConnectionFileDescriptor> conn_ap(new ConnectionFileDescriptor());
         if (conn_ap.get())
         {
             const uint32_t max_retry_count = 50;
             uint32_t retry_count = 0;
             while (!m_gdb_comm.IsConnected())
             {
                 if (conn_ap->Connect(connect_url, &error) == eConnectionStatusSuccess)

source/Target/Platform.cpp

 }
 
 Error
 Platform::PutFile (const FileSpec& source,
                    const FileSpec& destination,
                    uint32_t uid,
                    uint32_t gid)
 {
-    Error error("unimplemented");
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
+    if (log)
+        log->Printf("[PutFile] Using block by block transfer....\n");
+
+    uint32_t source_open_options = File::eOpenOptionRead;
+    if (source.GetFileType() == FileSpec::eFileTypeSymbolicLink)
+        source_open_options |= File::eOpenoptionDontFollowSymlinks;
+
+    File source_file(source, source_open_options, lldb::eFilePermissionsUserRW);
+    Error error;
+    uint32_t permissions = source_file.GetPermissions(error);
+    if (permissions == 0)
+        permissions = lldb::eFilePermissionsFileDefault;
+
+    if (!source_file.IsValid())
+        return Error("PutFile: unable to open source file");
+    lldb::user_id_t dest_file = OpenFile (destination,
+                                          File::eOpenOptionCanCreate |
+                                          File::eOpenOptionWrite |
+                                          File::eOpenOptionTruncate,
+                                          permissions,
+                                          error);
+    if (log)
+        log->Printf ("dest_file = %" PRIu64 "\n", dest_file);
+
+    if (error.Fail())
+        return error;
+    if (dest_file == UINT64_MAX)
+        return Error("unable to open target file");
+    lldb::DataBufferSP buffer_sp(new DataBufferHeap(1024, 0));
+    uint64_t offset = 0;
+    for (;;)
+    {
+        size_t bytes_read = buffer_sp->GetByteSize();
+        error = source_file.Read(buffer_sp->GetBytes(), bytes_read);
+        if (error.Fail() || bytes_read == 0)
+            break;
+
+        const uint64_t bytes_written = WriteFile(dest_file, offset,
+            buffer_sp->GetBytes(), bytes_read, error);
+        if (error.Fail())
+            break;
+
+        offset += bytes_written;
+        if (bytes_written != bytes_read)
+        {
+            // We didn't write the correct number of bytes, so adjust
+            // the file position in the source file we are reading from...
+            source_file.SeekFromStart(offset);
+        }
+    }
+    CloseFile(dest_file, error);
+
+    if (uid == UINT32_MAX && gid == UINT32_MAX)
+        return error;
+
+    // TODO: ChownFile?
+
     return error;
 }
 
 Error
 Platform::GetFile (const FileSpec& source,
                    const FileSpec& destination)
 {
     Error error("unimplemented");

source/Target/TargetList.cpp

if (triple_cstr && triple_cstr[0])
         }
     }
     
     ArchSpec platform_arch(arch);
 
     bool prefer_platform_arch = false;
     
     CommandInterpreter &interpreter = debugger.GetCommandInterpreter();
-    if (platform_options && platform_options->PlatformWasSpecified ())
+
+    // let's see if there is already an existing plaform before we go creating another...
+    platform_sp = debugger.GetPlatformList().GetSelectedPlatform();
+
+    if (!platform_sp && platform_options && platform_options->PlatformWasSpecified ())
     {
         const bool select_platform = true;
         platform_sp = platform_options->CreatePlatformWithOptions (interpreter,
                                                                    arch,
                                                                    select_platform,
                                                                    error,
                                                                    platform_arch);
         if (!platform_sp)

tools/lldb-gdbserver/lldb-gdbserver.cpp

if (host_and_port && host_and_port[0])
                 fprintf (stderr, "failed to join the listener thread\n");
                 display_usage (progname);
                 exit (1);
             }
 
             // Ensure we connected.
             if (s_listen_connection_up)
             {
-                printf ("Connection established.\n");
+                printf ("Connection established '%s'\n", s_listen_connection_up->GetURI().c_str());
                 gdb_server.SetConnection (s_listen_connection_up.release());
             }
             else
             {
                 fprintf (stderr, "failed to connect to '%s': %s\n", final_host_and_port.c_str (), error.AsCString ());
                 display_usage (progname);
                 exit (1);
             }
#endif
     }
 
     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());
     }
+    Log *log(lldb_private::GetLogIfAnyCategoriesSet (GDBR_LOG_VERBOSE));
+    if (log)
+    {
+        log->Printf ("lldb-gdbserver 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);