ThreadPlanSingleThreadTimeout.h

Go to the documentation of this file.

//===-- ThreadPlanSingleThreadTimeout.h -------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#ifndef LLDB_TARGET_THREADPLANSINGLETHREADTIMEOUT_H
#define LLDB_TARGET_THREADPLANSINGLETHREADTIMEOUT_H
 
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlan.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/State.h"
 
#include <chrono>
#include <thread>
 
namespace lldb_private {
 
class ThreadPlanSingleThreadTimeout;
//
// Thread plan used by single thread execution to issue timeout. This is useful
// to detect potential deadlock in single thread execution. The timeout measures
// the elapsed time from the last internal stop and gets reset by each internal
// stop to ensure we are accurately detecting execution not moving forward.
// This means this thread plan may be created/destroyed multiple times by the
// parent execution plan.
//
// When a timeout happens, the thread plan resolves the potential deadlock by
// issuing a thread specific async interrupt to enter stop state, then execution
// is resumed with all threads running to resolve the potential deadlock
//
class ThreadPlanSingleThreadTimeout : public ThreadPlan {
  enum class State {
    WaitTimeout,    // Waiting for timeout.
    AsyncInterrupt, // Async interrupt has been issued.
    Done,           // Finished resume all threads.
  };
 
public:
  // TODO: allow timeout to be set on per thread plan basis.
  struct TimeoutInfo {
    // Whether there is a ThreadPlanSingleThreadTimeout instance alive.
    bool m_isAlive = false;
    ThreadPlanSingleThreadTimeout::State m_last_state = State::WaitTimeout;
  };
  using TimeoutInfoSP =
      std::shared_ptr<ThreadPlanSingleThreadTimeout::TimeoutInfo>;
 
  ~ThreadPlanSingleThreadTimeout() override;
 
  // If input \param thread is running in single thread mode, push a
  // new ThreadPlanSingleThreadTimeout based on timeout setting from fresh new
  // state. The reference of \param info is passed in so that when
  // ThreadPlanSingleThreadTimeout got popped its last state can be stored
  // in it for future resume.
  static void PushNewWithTimeout(Thread &thread, TimeoutInfoSP &info);
 
  // Push a new ThreadPlanSingleThreadTimeout by restoring state from
  // input \param info and resume execution.
  static void ResumeFromPrevState(Thread &thread, TimeoutInfoSP &info);
 
  void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
  bool ValidatePlan(Stream *error) override { return true; }
  bool WillStop() override;
  void DidPop() override;
 
  bool IsLeafPlan() override { return true; }
  bool DoPlanExplainsStop(Event *event_ptr) override;
 
  lldb::StateType GetPlanRunState() override;
  static void TimeoutThreadFunc(ThreadPlanSingleThreadTimeout *self);
 
  bool MischiefManaged() override;
 
  bool ShouldStop(Event *event_ptr) override;
  void SetStopOthers(bool new_value) override;
  bool StopOthers() override;
 
private:
  ThreadPlanSingleThreadTimeout(Thread &thread, TimeoutInfoSP &info);
 
  bool IsTimeoutAsyncInterrupt(Event *event_ptr);
  bool HandleEvent(Event *event_ptr);
  void HandleTimeout();
  uint64_t GetRemainingTimeoutMilliSeconds();
 
  static std::string StateToString(State state);
 
  ThreadPlanSingleThreadTimeout(const ThreadPlanSingleThreadTimeout &) = delete;
  const ThreadPlanSingleThreadTimeout &
  operator=(const ThreadPlanSingleThreadTimeout &) = delete;
 
  TimeoutInfoSP m_info; // Reference to controlling ThreadPlan's TimeoutInfo.
  State m_state;
 
  // Lock for m_wakeup_cv and m_exit_flag between thread plan thread and timer
  // thread
  std::mutex m_mutex;
  std::condition_variable m_wakeup_cv;
  std::thread m_timer_thread;
  std::chrono::steady_clock::time_point m_timeout_start;
};
 
} // namespace lldb_private
 
#endif // LLDB_TARGET_THREADPLANSINGLETHREADTIMEOUT_H