Add wait timeout to process properties

[tatyana-krasnukha]

Summary

By default, the setting's value is 0 and it doesn't change the current behavior.
This setting allows the test-suite not to be hanging when something went wrong.

[tatyana-krasnukha]

Lit option --timeout partly solves the problem, so these changes are unnecessary.

lldb/include/lldb/Target/Process.h

public:
   void SetUnwindOnErrorInExpressions(bool ignore);
   bool GetStopOnSharedLibraryEvents() const;
   void SetStopOnSharedLibraryEvents(bool stop);
   bool GetDetachKeepsStopped() const;
   void SetDetachKeepsStopped(bool keep_stopped);
   bool GetWarningsOptimization() const;
   bool GetStopOnExec() const;
   std::chrono::seconds GetUtilityExpressionTimeout() const;
+  Timeout<std::micro> GetWatchdogTimeout() const;
 
 protected:
   Process *m_process; // Can be nullptr for global ProcessProperties
 };
 
 typedef std::shared_ptr<ProcessProperties> ProcessPropertiesSP;
 
 // ProcessAttachInfo

lldb/packages/Python/lldbsuite/test/lldbtest.py

def getSourcePath(self, name):
         return os.path.join(self.getSourceDir(), name)
 
     @classmethod
     def setUpCommands(cls):
         commands = [
             # First of all, clear all settings to have clean state of global properties.
             "settings clear -all",
 
+            # Set the timeout of 5 minutes for waiting a process to stop.
+            "settings set target.process.watchdog-timeout 300",
+
             # Disable Spotlight lookup. The testsuite creates
             # different binaries with the same UUID, because they only
             # differ in the debug info, which is not being hashed.
             "settings set symbols.enable-external-lookup false",
 
             # Disable fix-its by default so that incorrect expressions in tests don't
             # pass just because Clang thinks it has a fix-it.
             "settings set target.auto-apply-fixits false",

lldb/source/Target/Process.cpp

 
 std::chrono::seconds ProcessProperties::GetUtilityExpressionTimeout() const {
   const uint32_t idx = ePropertyUtilityExpressionTimeout;
   uint64_t value = m_collection_sp->GetPropertyAtIndexAsUInt64(
       nullptr, idx, g_process_properties[idx].default_uint_value);
   return std::chrono::seconds(value);
 }
 
+Timeout<std::micro> ProcessProperties::GetWatchdogTimeout() const {
+  const uint32_t idx = ePropertyWatchdogTimeout;
+  const uint64_t value = m_collection_sp->GetPropertyAtIndexAsUInt64(
+      nullptr, idx, g_process_properties[idx].default_uint_value);
+  if (value == 0)
+    return llvm::None;
+
+  return std::chrono::seconds(value);
+}
+
 Status ProcessLaunchCommandOptions::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Status error;
   const int short_option = m_getopt_table[option_idx].val;
 
   switch (short_option) {
   case 's': // Stop at program entry point
StateType Process::WaitForProcessToStop(const Timeout<std::micro> &timeout,
   if (event_sp_ptr)
     event_sp_ptr->reset();
   StateType state = GetState();
   // If we are exited or detached, we won't ever get back to any other valid
   // state...
   if (state == eStateDetached || state == eStateExited)
     return state;
 
+  auto wait_timeout = timeout ? timeout : GetWatchdogTimeout();
+
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
-  LLDB_LOG(log, "timeout = {0}", timeout);
+  LLDB_LOG(log, "timeout = {0}", wait_timeout);
 
   if (!wait_always && StateIsStoppedState(state, true) &&
       StateIsStoppedState(GetPrivateState(), true)) {
     LLDB_LOGF(log,
               "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_sp && use_run_lock)
       m_public_run_lock.SetStopped();
     return state;
   }
 
   while (state != eStateInvalid) {
     EventSP event_sp;
-    state = GetStateChangedEvents(event_sp, timeout, hijack_listener_sp);
+    state = GetStateChangedEvents(event_sp, wait_timeout, hijack_listener_sp);
     if (event_sp_ptr && event_sp)
       *event_sp_ptr = event_sp;
 
     bool pop_process_io_handler = (hijack_listener_sp.get() != nullptr);
     Process::HandleProcessStateChangedEvent(event_sp, stream,
                                             pop_process_io_handler);
 
     switch (state) {
Status Process::ResumeSynchronous(Stream *stream) {
   }
 
   ListenerSP listener_sp(
       Listener::MakeListener(g_resume_sync_name));
   HijackProcessEvents(listener_sp);
 
   Status error = PrivateResume();
   if (error.Success()) {
-    StateType state =
-        WaitForProcessToStop(llvm::None, nullptr, true, listener_sp, stream);
+    StateType state = WaitForProcessToStop(
+        GetWatchdogTimeout(), nullptr, true, listener_sp, stream);
     const bool must_be_alive =
         false; // eStateExited is ok, so this must be false
     if (!StateIsStoppedState(state, must_be_alive))
       error.SetErrorStringWithFormat(
           "process not in stopped state after synchronous resume: %s",
           StateAsCString(state));
   } else {
     // Undo running state change

lldb/source/Target/TargetProperties.td

def WarningOptimization: Property<"optimization-warnings", "Boolean">,
     Desc<"If true, warn when stopped in code that is optimized where stepping and variable availability may not behave as expected.">;
   def StopOnExec: Property<"stop-on-exec", "Boolean">,
     Global,
     DefaultTrue,
     Desc<"If true, stop when a shared library is loaded or unloaded.">;
   def UtilityExpressionTimeout: Property<"utility-expression-timeout", "UInt64">,
     DefaultUnsignedValue<15>,
     Desc<"The time in seconds to wait for LLDB-internal utility expressions.">;
+  def WatchdogTimeout: Property<"watchdog-timeout", "UInt64">,
+    DefaultUnsignedValue<0>,
+    Desc<"The time in seconds to wait for process to stop. Zero means unfinite wait.">;
 }
 
 let Definition = "platform" in {
   def UseModuleCache: Property<"use-module-cache", "Boolean">,
     Global,
     DefaultTrue,
     Desc<"Use module cache.">;
   def ModuleCacheDirectory: Property<"module-cache-directory", "FileSpec">,