Fix race condition with -o "process launch" on linux

[labath]

Summary

starting a debug session on linux with -o "process launch" lldb parameter was failing since
Target::Launch (in sychronous mode) is expecting to be able to receive public process events.
However, PlatformLinux did not set up event hijacking on process launch, which caused these
events to be processed elsewhere and left Target::Launch hanging. This patch enables event
interception in PlatformLinux (which was commented out).

Upon enabling event interception, I noticed an issue, which I traced back to the inconsistent
state of public run lock, which remained false even though public and private process states were
"stopped". I addressed this by making sure the run lock is "stopped" upon exit from
WaitForProcessToStop (which already had similar provisions for other return paths).

[clayborg]

If you hijack events, you must undo this by calling:

process_sp->RestoreProcessEvents();

source/Plugins/Platform/Linux/PlatformLinux.cpp

804 ↗

(On Diff #21269)

If you hijack event above, you must unhijack by calling:

process_sp->RestoreProcessEvents();

So you can't remove this. It was a NOP before because it wasn't doing anything, but if you do hijack events, then you must unhijack.

[labath]

source/Plugins/Platform/Linux/PlatformLinux.cpp

804 ↗

(On Diff #21269)

Ok, this sure does look dodgy when you look at it alone. :)
This hijacking will be restored later in Target::Launch (line 2689). I believe it is expected behavior for the DebugProcess function to exit with event hijacking on. For example, the base Platform::DebugProcess also hijacks events on line 1188, but does not restore it by itself.

[clayborg]

ok, looks good then.

lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp

else
             log->Printf ("PlatformLinux::%s successfully created process", __FUNCTION__);
     }
 
     // Set the unix signals properly.
     process_sp->SetUnixSignals (Host::GetUnixSignals ());
 
     // Adjust launch for a hijacker.
     ListenerSP listener_sp;
-#if 0
     if (!launch_info.GetHijackListener ())
     {
         if (log)
             log->Printf ("PlatformLinux::%s setting up hijacker", __FUNCTION__);
 
         listener_sp.reset (new Listener("lldb.PlatformLinux.DebugProcess.hijack"));
         launch_info.SetHijackListener (listener_sp);
         process_sp->HijackProcessEvents (listener_sp.get ());
     }
-#endif
 
     // Log file actions.
     if (log)
     {
         log->Printf ("PlatformLinux::%s launching process with the following file actions:", __FUNCTION__);
 
         StreamString stream;
         size_t i = 0;
PlatformLinux::DebugProcess (ProcessLaunchInfo &launch_info,
     // Do the launch.
     error = process_sp->Launch(launch_info);
     if (error.Success ())
     {
         // Handle the hijacking of process events.
         if (listener_sp)
         {
             const StateType state = process_sp->WaitForProcessToStop (NULL, NULL, false, listener_sp.get());
-            process_sp->RestoreProcessEvents();
 
             if (state == eStateStopped)
             {
                 if (log)
                     log->Printf ("PlatformLinux::%s pid %" PRIu64 " state %s\n",
                                  __FUNCTION__, process_sp->GetID (), StateAsCString (state));
             }
             else

lldb/trunk/source/Target/Process.cpp

if (log)
                      static_cast<const void*>(timeout));
 
     if (!wait_always &&
         StateIsStoppedState(state, true) &&
         StateIsStoppedState(GetPrivateState(), true)) {
         if (log)
             log->Printf("Process::%s returning without waiting for events; process private and public states are already 'stopped'.",
                         __FUNCTION__);
+        // We need to toggle the run lock as this won't get done in
+        // SetPublicState() if the process is hijacked.
+        if (hijack_listener)
+            m_public_run_lock.SetStopped();
         return state;
     }
 
     while (state != eStateInvalid)
     {
         EventSP event_sp;
         state = WaitForStateChangedEvents (timeout, event_sp, hijack_listener);
         if (event_sp_ptr && event_sp)