Fix 'process launch -i' for remote processes

[vharron]

Summary

renamed m_stdio_disable to m_stdin_forward and inverted value because
that's what we want to remember

There was previously a bug that if you redirected stdin from a file,
stdout and stderr would also be redirected to /dev/null

Adds support for remote target to TestProcessIO.py

Fixes ProcessIOTestCase.test_stdin_redirection_with_dwarf for remote
Linux targets

[clayborg]

lgtm

[vharron]

committed

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
+    bool                        m_stdin_forward;           /// Remember if stdin must be forwarded to remote debug server
     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/ProcessGDBRemote.cpp

if (log)
                          __FUNCTION__,
                          stdin_path ? stdin_path : "<null>",
                          stdout_path ? stdout_path : "<null>",
                          stderr_path ? stderr_path : "<null>");
         else
             log->Printf ("ProcessGDBRemote::%s no STDIO paths given via launch_info", __FUNCTION__);
     }
 
+    const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
+    if (stdin_path || disable_stdio)
+    {
+        // the inferior will be reading stdin from the specified file
+        // or stdio is completely disabled
+        m_stdin_forward = false;
+    }
+    else
+    {
+        m_stdin_forward = true;
+    }
+
     //  ::LogSetBitMask (GDBR_LOG_DEFAULT);
     //  ::LogSetOptions (LLDB_LOG_OPTION_THREADSAFE | LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD);
     //  ::LogSetLogFile ("/dev/stdout");
 
     ObjectFile * object_file = exe_module->GetObjectFile();
     if (object_file)
     {
         // Make sure we aren't already connected?
         if (!m_gdb_comm.IsConnected())
         {
             error = LaunchAndConnectToDebugserver (launch_info);
         }
         
         if (error.Success())
         {
             lldb_utility::PseudoTerminal pty;
             const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
 
+            PlatformSP platform_sp (m_target.GetPlatform());
+            if (disable_stdio)
+            {
+                // set to /dev/null unless redirected to a file above
+                if (!stdin_path)
+                    stdin_path = "/dev/null";
+                if (!stdout_path)
+                    stdout_path = "/dev/null";
+                if (!stderr_path)
+                    stderr_path = "/dev/null";
+            }
+            else if (platform_sp && platform_sp->IsHost())
+            {
                 // If the debugserver is local and we aren't disabling STDIO, lets use
                 // a pseudo terminal to instead of relying on the 'O' packets for stdio
-            // since 'O' packets can really slow down debugging if the inferior 
+                // since 'O' packets can really slow down debugging if the inferior
                 // does a lot of output.
-            PlatformSP platform_sp (m_target.GetPlatform());
-            if (platform_sp && platform_sp->IsHost() && !disable_stdio)
-            {
                 const char *slave_name = NULL;
                 if (stdin_path == NULL || stdout_path == NULL || stderr_path == NULL)
                 {
                     if (pty.OpenFirstAvailableMaster(O_RDWR|O_NOCTTY, NULL, 0))
                         slave_name = pty.GetSlaveName (NULL, 0);
                 }
                 if (stdin_path == NULL) 
                     stdin_path = slave_name;
 
                 if (stdout_path == NULL)
                     stdout_path = slave_name;
 
                 if (stderr_path == NULL)
                     stderr_path = slave_name;
 
                 if (log)
                     log->Printf ("ProcessGDBRemote::%s adjusted STDIO paths for local platform (IsHost() is true) using slave: stdin=%s, stdout=%s, stdout=%s",
                                  __FUNCTION__,
                                  stdin_path ? stdin_path : "<null>",
                                  stdout_path ? stdout_path : "<null>",
                                  stderr_path ? stderr_path : "<null>");
             }
 
-            // Set STDIN to /dev/null if we want STDIO disabled or if either
-            // STDOUT or STDERR have been set to something and STDIN hasn't
-            if (disable_stdio || (stdin_path == NULL && (stdout_path || stderr_path)))
-                stdin_path = "/dev/null";
-            
-            // Set STDOUT to /dev/null if we want STDIO disabled or if either
-            // STDIN or STDERR have been set to something and STDOUT hasn't
-            if (disable_stdio || (stdout_path == NULL && (stdin_path || stderr_path)))
-                stdout_path = "/dev/null";
-            
-            // Set STDERR to /dev/null if we want STDIO disabled or if either
-            // STDIN or STDOUT have been set to something and STDERR hasn't
-            if (disable_stdio || (stderr_path == NULL && (stdin_path || stdout_path)))
-                stderr_path = "/dev/null";
-
             if (log)
                 log->Printf ("ProcessGDBRemote::%s final STDIO paths after all adjustments: stdin=%s, stdout=%s, stdout=%s",
                              __FUNCTION__,
                              stdin_path ? stdin_path : "<null>",
                              stdout_path ? stdout_path : "<null>",
                              stderr_path ? stderr_path : "<null>");
 
             if (stdin_path)
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)
+    else if (m_stdin_forward)
     {
         m_gdb_comm.SendStdinNotification(src, src_len);
     }
     return 0;
 }
 
 Error
 ProcessGDBRemote::EnableBreakpointSite (BreakpointSite *bp_site)

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_stdin_forward (false),
     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;
+        m_stdin_forward = false;
 
         if (m_process_input_reader)
         {
             m_process_input_reader->SetIsDone(true);
             m_process_input_reader->Cancel();
             m_process_input_reader.reset();
         }
 

test/python_api/process/io/TestProcessIO.py

def test_stdout_stderr_redirection_with_dwarf(self):
         self.buildDwarf()
         self.do_stdout_stderr_redirection()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Get the full path to our executable to be debugged.
         self.exe = os.path.join(os.getcwd(), "process_io")
-        self.input_file  = os.path.join(os.getcwd(), "input.txt")
-        self.output_file = os.path.join(os.getcwd(), "output.txt")
-        self.error_file  = os.path.join(os.getcwd(), "error.txt")
+        self.local_input_file  = os.path.join(os.getcwd(), "input.txt")
+        self.local_output_file = os.path.join(os.getcwd(), "output.txt")
+        self.local_error_file  = os.path.join(os.getcwd(), "error.txt")
+
+        self.input_file  = os.path.join(self.get_process_working_directory(), "input.txt")
+        self.output_file = os.path.join(self.get_process_working_directory(), "output.txt")
+        self.error_file  = os.path.join(self.get_process_working_directory(), "error.txt")
         self.lines = ["Line 1", "Line 2", "Line 3"]
     
     def read_output_file_and_delete (self):
         self.assertTrue(os.path.exists(self.output_file), "Make sure output.txt file exists")
         f = open(self.output_file, 'r')
         contents = f.read()
         f.close()
         os.unlink(self.output_file)
def create_target(self):
         self.launch_info.SetWorkingDirectory(self.get_process_working_directory())
     
     def redirect_stdin(self):
         '''Redirect STDIN (file descriptor 0) to use our input.txt file
 
         Make the input.txt file to use when redirecting STDIN, setup a cleanup action
         to delete the input.txt at the end of the test in case exceptions are thrown,
         and redirect STDIN in the launch info.'''
-        f = open(self.input_file, 'w')
+        f = open(self.local_input_file, 'w')
         for line in self.lines:
             f.write(line + "\n")
         f.close()
+
+        if lldb.remote_platform:
+            self.runCmd('platform put-file "{local}" "{remote}"'.format(
+                local=self.local_input_file, remote=self.input_file))
+
         # This is the function to remove the custom formats in order to have a
         # clean slate for the next test case.
         def cleanup():
-            os.unlink(self.input_file)
-        
+            os.unlink(self.local_input_file)
+            # if lldb.remote_platform:
+                # TODO: add delete file command
+                # self.runCmd('platform delete-file "{local}" "{remote}"'.format(
+                #    local=self.local_input_file, remote=self.input_file))'''
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
         self.launch_info.AddOpenFileAction(0, self.input_file, True, False);
         
     def redirect_stdout(self):
         '''Redirect STDOUT (file descriptor 1) to use our output.txt file'''
         self.launch_info.AddOpenFileAction(1, self.output_file, False, True);