Add support for SBProcess::PutSTDIN to remote processes

[vharron]

Summary

Processes running on a remote target can already send $O messages
to send stdout but there is no way to send stdin to a remote
inferior.

This allows processes using the API to pump stdin into a remote
inferior process.

It fixes a hang in TestProcessIO.py

[vharron]

No affect on OSX tests

[vharron]

It fixes a hang in TestProcessIO.py

When running against a remote target

[clayborg]

Looks good.

[vharron]

Committed: r228419

include/lldb/Target/Process.h

protected:
     std::unique_ptr<DynamicCheckerFunctions> m_dynamic_checkers_ap; ///< The functions used by the expression parser to validate data that expressions use.
     std::unique_ptr<OperatingSystem> m_os_ap;
     std::unique_ptr<SystemRuntime> m_system_runtime_ap;
     UnixSignalsSP               m_unix_signals_sp;         /// This is the current signal set for this process.
     lldb::ABISP                 m_abi_sp;
     lldb::IOHandlerSP           m_process_input_reader;
     Communication               m_stdio_communication;
     Mutex                       m_stdio_communication_mutex;
+    bool                        m_stdio_disable;           /// Remember process launch setting
     std::string                 m_stdout_data;
     std::string                 m_stderr_data;
     Mutex                       m_profile_data_comm_mutex;
     std::vector<std::string>    m_profile_data;
     Predicate<bool>             m_iohandler_sync;
     MemoryCache                 m_memory_cache;
     AllocatedMemoryCache        m_allocated_memory_cache;
     bool                        m_should_detach;   /// Should we detach if the process object goes away with an explicit call to Kill or Detach?

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

public:
     ///     an error code.
     //------------------------------------------------------------------
     int
     SendAttach (lldb::pid_t pid, 
                 StringExtractorGDBRemote& response);
 
 
     //------------------------------------------------------------------
+    /// Sends a GDB remote protocol 'I' packet that delivers stdin
+    /// data to the remote process.
+    ///
+    /// @param[in] data
+    ///     A pointer to stdin data.
+    ///
+    /// @param[in] data_len
+    ///     The number of bytes available at \a data.
+    ///
+    /// @return
+    ///     Zero if the attach was successful, or an error indicating
+    ///     an error code.
+    //------------------------------------------------------------------
+    int
+    SendStdinNotification(const char* data, size_t data_len);
+
+    //------------------------------------------------------------------
     /// Sets the path to use for stdin/out/err for a process
     /// that will be launched with the 'A' packet.
     ///
     /// @param[in] path
     ///     The path to use for stdin/out/err
     ///
     /// @return
     ///     Zero if the for success, or an error code for failure.

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

if (pid != LLDB_INVALID_PROCESS_ID)
             if (response.IsErrorResponse())
                 return response.GetError();
             return 0;
         }
     }
     return -1;
 }
 
+int
+GDBRemoteCommunicationClient::SendStdinNotification (const char* data, size_t data_len)
+{
+    StreamString packet;
+    packet.PutCString("I");
+    packet.PutBytesAsRawHex8(data, data_len);
+    StringExtractorGDBRemote response;
+    if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
+    {
+        return 0;
+    }
+    return response.GetError();
+
+}
+
 const lldb_private::ArchSpec &
 GDBRemoteCommunicationClient::GetHostArchitecture ()
 {
     if (m_qHostInfo_is_valid == eLazyBoolCalculate)
         GetHostInfo ();
     return m_host_arch;
 }
 

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

protected:
 
     PacketResult
     Handle_P (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_H (StringExtractorGDBRemote &packet);
 
     PacketResult
+    Handle_I (StringExtractorGDBRemote &packet);
+
+    PacketResult
     Handle_interrupt (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_m (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_M (StringExtractorGDBRemote &packet);
 

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

if (packet_result == PacketResult::Success)
         case StringExtractorGDBRemote::eServerPacketType_P:
             packet_result = Handle_P (packet);
             break;
 
         case StringExtractorGDBRemote::eServerPacketType_H:
             packet_result = Handle_H (packet);
             break;
 
+        case StringExtractorGDBRemote::eServerPacketType_I:
+            packet_result = Handle_I (packet);
+            break;
+
         case StringExtractorGDBRemote::eServerPacketType_m:
             packet_result = Handle_m (packet);
             break;
 
         case StringExtractorGDBRemote::eServerPacketType_M:
             packet_result = Handle_M (packet);
             break;
 
switch (h_variant)
             assert (false && "unsupported $H variant - shouldn't get here");
             return SendIllFormedResponse (packet, "H variant unsupported, should be c or g");
     }
 
     return SendOKResponse();
 }
 
 GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_I (StringExtractorGDBRemote &packet)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
+
+    // Ensure we're llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse("GDBRemoteCommunicationServer::Handle_I() unimplemented");
+
+    // Fail if we don't have a current process.
+    if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, no process available", __FUNCTION__);
+        return SendErrorResponse (0x15);
+    }
+
+    packet.SetFilePos (::strlen("I"));
+    char tmp[4096];
+    for (;;)
+    {
+        size_t read = packet.GetHexBytesAvail(tmp, sizeof(tmp));
+        if (read == 0)
+        {
+            break;
+        }
+        // write directly to stdin *this might block if stdin buffer is full*
+        // TODO: enqueue this block in circular buffer and send window size to remote host
+        ConnectionStatus status;
+        Error error;
+        m_stdio_communication.Write(tmp, read, status, &error);
+        if (error.Fail())
+        {
+            return SendErrorResponse (0x15);
+        }
+    }
+
+    return SendOKResponse();
+}
+
+GDBRemoteCommunicationServer::PacketResult
 GDBRemoteCommunicationServer::Handle_interrupt (StringExtractorGDBRemote &packet)
 {
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
 
     // Ensure we're llgs.
     if (!IsGdbServer())
     {
         // Only supported on llgs

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

if (object_file)
                     else
                     {
                         m_target.SetArchitecture(m_gdb_comm.GetHostArchitecture());
                     }
                 }
 
                 SetPrivateState (SetThreadStopInfo (m_last_stop_packet));
                 
+                m_stdio_disable = disable_stdio;
                 if (!disable_stdio)
                 {
                     if (pty.GetMasterFileDescriptor() != lldb_utility::PseudoTerminal::invalid_fd)
                         SetSTDIOFileDescriptor (pty.ReleaseMasterFileDescriptor());
                 }
             }
         }
         else

 size_t
 ProcessGDBRemote::PutSTDIN (const char *src, size_t src_len, Error &error)
 {
     if (m_stdio_communication.IsConnected())
     {
         ConnectionStatus status;
         m_stdio_communication.Write(src, src_len, status, NULL);
     }
+    else if (!m_stdio_disable)
+    {
+        m_gdb_comm.SendStdinNotification(src, src_len);
+    }
     return 0;
 }
 
 Error
 ProcessGDBRemote::EnableBreakpointSite (BreakpointSite *bp_site)
 {
     Error error;
     assert(bp_site != NULL);

source/Target/Process.cpp

Process::Process(Target &target, Listener &listener, const UnixSignalsSP &unix_signals_sp) :
     m_listener (listener),
     m_breakpoint_site_list (),
     m_dynamic_checkers_ap (),
     m_unix_signals_sp (unix_signals_sp),
     m_abi_sp (),
     m_process_input_reader (),
     m_stdio_communication ("process.stdio"),
     m_stdio_communication_mutex (Mutex::eMutexTypeRecursive),
+    m_stdio_disable(true),
     m_stdout_data (),
     m_stderr_data (),
     m_profile_data_comm_mutex (Mutex::eMutexTypeRecursive),
     m_profile_data (),
     m_iohandler_sync (false),
     m_memory_cache (*this),
     m_allocated_memory_cache (*this),
     m_should_detach (false),
if (error.Success())
         error = DoDestroy();
         if (error.Success())
         {
             DidDestroy();
             StopPrivateStateThread();
         }
         m_stdio_communication.StopReadThread();
         m_stdio_communication.Disconnect();
+        m_stdio_disable = true;
 
         if (m_process_input_reader)
         {
             m_process_input_reader->SetIsDone(true);
             m_process_input_reader->Cancel();
             m_process_input_reader.reset();
         }
 

source/Utility/StringExtractorGDBRemote.h

enum ServerPacketType
         eServerPacketType_stop_reason, // '?'
 
         eServerPacketType_c,
         eServerPacketType_C,
         eServerPacketType_D,
         eServerPacketType_g,
         eServerPacketType_G,
         eServerPacketType_H,
+        eServerPacketType_I, // stdin notification
         eServerPacketType_k,
         eServerPacketType_m,
         eServerPacketType_M,
         eServerPacketType_p,
         eServerPacketType_P,
         eServerPacketType_s,
         eServerPacketType_S,
         eServerPacketType_T,

source/Utility/StringExtractorGDBRemote.cpp

case 'v':
         break;
 
       case 'G':
         return eServerPacketType_G;
 
       case 'H':
         return eServerPacketType_H;
 
+      case 'I':
+        return eServerPacketType_I;
+
       case 'k':
         if (packet_size == 1) return eServerPacketType_k;
         break;
 
       case 'm':
         return eServerPacketType_m;
 
       case 'M':