lldb/source/Plugins/Process/Darwin/NativeThreadDarwin.cpp

//===-- NativeThreadDarwin.cpp -------------------------------- -*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "NativeThreadDarwin.h"

// C includes
#include <libproc.h>

// LLDB includes
#include "lldb/Utility/Stream.h"

#include "NativeProcessDarwin.h"

using namespace lldb;
using namespace lldb_private;
using namespace lldb_private::process_darwin;

uint64_t NativeThreadDarwin::GetGloballyUniqueThreadIDForMachPortID(
    ::thread_t mach_port_id) {
  thread_identifier_info_data_t tident;
  mach_msg_type_number_t tident_count = THREAD_IDENTIFIER_INFO_COUNT;

  auto mach_err = ::thread_info(mach_port_id, THREAD_IDENTIFIER_INFO,
                                (thread_info_t)&tident, &tident_count);
  if (mach_err != KERN_SUCCESS) {
    // When we fail to get thread info for the supposed port, assume it is
    // really a globally unique thread id already, or return the best thing
    // we can, which is the thread port.
    return mach_port_id;
  }
  return tident.thread_id;
}

NativeThreadDarwin::NativeThreadDarwin(NativeProcessDarwin *process,
                                       bool is_64_bit,
                                       lldb::tid_t unique_thread_id,
                                       ::thread_t mach_thread_port)
    : NativeThreadProtocol(process, unique_thread_id),
      m_mach_thread_port(mach_thread_port), m_basic_info(),
      m_proc_threadinfo() {}

bool NativeThreadDarwin::GetIdentifierInfo() {
  // Don't try to get the thread info once and cache it for the life of the
  // thread.  It changes over time, for instance
  // if the thread name changes, then the thread_handle also changes...  So you
  // have to refetch it every time.
  mach_msg_type_number_t count = THREAD_IDENTIFIER_INFO_COUNT;
  kern_return_t kret = ::thread_info(m_mach_thread_port, THREAD_IDENTIFIER_INFO,
                                     (thread_info_t)&m_ident_info, &count);
  return kret == KERN_SUCCESS;

  return false;
}

std::string NativeThreadDarwin::GetName() {
  std::string name;

  if (GetIdentifierInfo()) {
    auto process_sp = GetProcess();
    if (!process_sp) {
      name = "<unavailable>";
      return name;
    }

    int len = ::proc_pidinfo(process_sp->GetID(), PROC_PIDTHREADINFO,
                             m_ident_info.thread_handle, &m_proc_threadinfo,
                             sizeof(m_proc_threadinfo));

    if (len && m_proc_threadinfo.pth_name[0])
      name = m_proc_threadinfo.pth_name;
  }
  return name;
}

lldb::StateType NativeThreadDarwin::GetState() {
  // TODO implement
  return eStateInvalid;
}

bool NativeThreadDarwin::GetStopReason(ThreadStopInfo &stop_info,
                                       std::string &description) {
  // TODO implement
  return false;
}

NativeRegisterContextSP NativeThreadDarwin::GetRegisterContext() {
  // TODO implement
  return NativeRegisterContextSP();
}

Status NativeThreadDarwin::SetWatchpoint(lldb::addr_t addr, size_t size,
                                         uint32_t watch_flags, bool hardware) {
  Status error;
  error.SetErrorString("not yet implemented");
  return error;
}

Status NativeThreadDarwin::RemoveWatchpoint(lldb::addr_t addr) {
  Status error;
  error.SetErrorString("not yet implemented");
  return error;
}

void NativeThreadDarwin::Dump(Stream &stream) const {
// This is what we really want once we have the thread class wired up.
#if 0
    DNBLogThreaded("[%3u] #%3u tid: 0x%8.8" PRIx64 ", pc: 0x%16.16" PRIx64 ", sp: 0x%16.16" PRIx64 ", user: %d.%6.6d, system: %d.%6.6d, cpu: %2d, policy: %2d, run_state: %2d (%s), flags: %2d, suspend_count: %2d (current %2d), sleep_time: %d",
                   index,
                   m_seq_id,
                   m_unique_id,
                   GetPC(INVALID_NUB_ADDRESS),
                   GetSP(INVALID_NUB_ADDRESS),
                   m_basic_info.user_time.seconds,      m_basic_info.user_time.microseconds,
                   m_basic_info.system_time.seconds,    m_basic_info.system_time.microseconds,
                   m_basic_info.cpu_usage,
                   m_basic_info.policy,
                   m_basic_info.run_state,
                   thread_run_state,
                   m_basic_info.flags,
                   m_basic_info.suspend_count, m_suspend_count,
                   m_basic_info.sleep_time);

#else
  // Here's all we have right now.
  stream.Printf("tid: 0x%8.8" PRIx64 ", thread port: 0x%4.4x", GetID(),
                m_mach_thread_port);
#endif
}

bool NativeThreadDarwin::NotifyException(MachException::Data &exc) {
// TODO implement this.
#if 0
    // Allow the arch specific protocol to process (MachException::Data &)exc
    // first before possible reassignment of m_stop_exception with exc.
    // See also MachThread::GetStopException().
    bool handled = m_arch_ap->NotifyException(exc);

    if (m_stop_exception.IsValid())
    {
        // We may have more than one exception for a thread, but we need to
        // only remember the one that we will say is the reason we stopped.
        // We may have been single stepping and also gotten a signal exception,
        // so just remember the most pertinent one.
        if (m_stop_exception.IsBreakpoint())
            m_stop_exception = exc;
    }
    else
    {
        m_stop_exception = exc;
    }

    return handled;
#else
  // Pretend we handled it.
  return true;
#endif
}

bool NativeThreadDarwin::ShouldStop(bool &step_more) const {
// TODO: implement this
#if 0
    // See if this thread is at a breakpoint?
    DNBBreakpoint *bp = CurrentBreakpoint();

    if (bp)
    {
        // This thread is sitting at a breakpoint, ask the breakpoint
        // if we should be stopping here.
        return true;
    }
    else
    {
        if (m_arch_ap->StepNotComplete())
        {
            step_more = true;
            return false;
        }
        // The thread state is used to let us know what the thread was
        // trying to do. MachThread::ThreadWillResume() will set the
        // thread state to various values depending if the thread was
        // the current thread and if it was to be single stepped, or
        // resumed.
        if (GetState() == eStateRunning)
        {
            // If our state is running, then we should continue as we are in
            // the process of stepping over a breakpoint.
            return false;
        }
        else
        {
            // Stop if we have any kind of valid exception for this
            // thread.
            if (GetStopException().IsValid())
                return true;
        }
    }
    return false;
#else
  return false;
#endif
}

void NativeThreadDarwin::ThreadDidStop() {
// TODO implement this.
#if 0
    // This thread has existed prior to resuming under debug nub control,
    // and has just been stopped. Do any cleanup that needs to be done
    // after running.

    // The thread state and breakpoint will still have the same values
    // as they had prior to resuming the thread, so it makes it easy to check
    // if we were trying to step a thread, or we tried to resume while being
    // at a breakpoint.

    // When this method gets called, the process state is still in the
    // state it was in while running so we can act accordingly.
    m_arch_ap->ThreadDidStop();


    // We may have suspended this thread so the primary thread could step
    // without worrying about race conditions, so lets restore our suspend
    // count.
    RestoreSuspendCountAfterStop();

    // Update the basic information for a thread
    MachThread::GetBasicInfo(m_mach_port_number, &m_basic_info);

    if (m_basic_info.suspend_count > 0)
        SetState(eStateSuspended);
    else
        SetState(eStateStopped);
#endif
}

bool NativeThreadDarwin::MachPortNumberIsValid(::thread_t thread) {
  return thread != (::thread_t)(0);
}

const struct thread_basic_info *NativeThreadDarwin::GetBasicInfo() const {
  if (GetBasicInfo(m_mach_thread_port, &m_basic_info))
    return &m_basic_info;
  return NULL;
}

bool NativeThreadDarwin::GetBasicInfo(::thread_t thread,
                                      struct thread_basic_info *basicInfoPtr) {
  if (MachPortNumberIsValid(thread)) {
    unsigned int info_count = THREAD_BASIC_INFO_COUNT;
    kern_return_t err = ::thread_info(thread, THREAD_BASIC_INFO,
                                      (thread_info_t)basicInfoPtr, &info_count);
    if (err == KERN_SUCCESS)
      return true;
  }
  ::memset(basicInfoPtr, 0, sizeof(struct thread_basic_info));
  return false;
}

bool NativeThreadDarwin::IsUserReady() const {
  if (m_basic_info.run_state == 0)
    GetBasicInfo();

  switch (m_basic_info.run_state) {
  default:
  case TH_STATE_UNINTERRUPTIBLE:
    break;

  case TH_STATE_RUNNING:
  case TH_STATE_STOPPED:
  case TH_STATE_WAITING:
  case TH_STATE_HALTED:
    return true;
  }
  return false;
}

NativeProcessDarwinSP NativeThreadDarwin::GetNativeProcessDarwinSP() {
  return std::static_pointer_cast<NativeProcessDarwin>(GetProcess());
}