Work around a stepping bug in arm64 android M

[labath]

Summary

On arm64, linux<=4.4 and Android<=M there is a bug, which prevents single-stepping from working when
the system comes back from suspend, because of incorrectly initialized CPUs. This did not really
affect Android<M, because it did not use software suspend, but it is a problem for M, which uses
suspend (doze) quite extensively. Fortunately, it seems that the first CPU is not affected by
this bug, so this commit implements a workaround by forcing the inferior to execute on the first
cpu whenever we are doing single stepping.

While inside, I have moved the implementations of Resume() and SingleStep() to the thread class
(instead of process).

[labath]

Avoid an unused function warning on non-arm64 arches.

[ovyalov]

source/Plugins/Process/Linux/NativeThreadLinux.cpp

250 ↗

(On Diff #48690)

Could you use Error error(errno, eErrorTypePOSIX) instead of strerror here?

source/Plugins/Process/Linux/SingleStepCheck.cpp

79 ↗

(On Diff #48690)

Kill child before return?

source/Plugins/Process/Linux/SingleStepCheck.h

41 ↗

(On Diff #48690)

s/liblldb_NativeThreadLinux_H_/liblldb_SingleStepCheck_H_

lldb/trunk/source/Plugins/Process/Linux/CMakeLists.txt

 include_directories(.)
 include_directories(../POSIX)
 include_directories(../Utility)
 
 add_lldb_library(lldbPluginProcessLinux
   NativeProcessLinux.cpp
   NativeRegisterContextLinux.cpp
   NativeRegisterContextLinux_arm.cpp
   NativeRegisterContextLinux_arm64.cpp
   NativeRegisterContextLinux_x86_64.cpp
   NativeRegisterContextLinux_mips64.cpp
   NativeThreadLinux.cpp
   ProcFileReader.cpp
+  SingleStepCheck.cpp
   )

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.h

public:
         static Error
         PtraceWrapper(int req,
                       lldb::pid_t pid,
                       void *addr = nullptr,
                       void *data = nullptr,
                       size_t data_size = 0,
                       long *result = nullptr);
 
+        bool
+        SupportHardwareSingleStepping() const;
+
     protected:
         // ---------------------------------------------------------------------
         // NativeProcessProtocol protected interface
         // ---------------------------------------------------------------------
         Error
         GetSoftwareBreakpointTrapOpcode (size_t trap_opcode_size_hint, size_t &actual_opcode_size, const uint8_t *&trap_opcode_bytes) override;
 
     private:
private:
         MonitorBreakpoint(NativeThreadLinux &thread);
 
         void
         MonitorWatchpoint(NativeThreadLinux &thread, uint32_t wp_index);
 
         void
         MonitorSignal(const siginfo_t &info, NativeThreadLinux &thread, bool exited);
 
-        bool
-        SupportHardwareSingleStepping() const;
-
         Error
         SetupSoftwareSingleStepping(NativeThreadLinux &thread);
 
 #if 0
         static ::ProcessMessage::CrashReason
         GetCrashReasonForSIGSEGV(const siginfo_t *info);
 
         static ::ProcessMessage::CrashReason
#endif
         GetSignalInfo(lldb::tid_t tid, void *siginfo);
 
         /// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG)
         /// corresponding to the given thread ID to the memory pointed to by @p
         /// message.
         Error
         GetEventMessage(lldb::tid_t tid, unsigned long *message);
 
-        /// Resumes the given thread.  If @p signo is anything but
-        /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread.
-        Error
-        Resume(lldb::tid_t tid, uint32_t signo);
-
-        /// Single steps the given thread.  If @p signo is anything but
-        /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread.
-        Error
-        SingleStep(lldb::tid_t tid, uint32_t signo);
-
         void
         NotifyThreadDeath (lldb::tid_t tid);
 
         Error
         Detach(lldb::tid_t tid);
 
 
         // This method is requests a stop on all threads which are still running. It sets up a

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

for (bytes_written = 0; bytes_written < size; bytes_written += remainder)
         src += k_ptrace_word_size;
     }
     if (log)
         ProcessPOSIXLog::DecNestLevel();
     return error;
 }
 
 Error
-NativeProcessLinux::Resume (lldb::tid_t tid, uint32_t signo)
-{
-    Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
-
-    if (log)
-        log->Printf ("NativeProcessLinux::%s() resuming thread = %"  PRIu64 " with signal %s", __FUNCTION__, tid,
-                                 Host::GetSignalAsCString(signo));
-
-
-
-    intptr_t data = 0;
-
-    if (signo != LLDB_INVALID_SIGNAL_NUMBER)
-        data = signo;
-
-    Error error = PtraceWrapper(PTRACE_CONT, tid, nullptr, (void*)data);
-
-    if (log)
-        log->Printf ("NativeProcessLinux::%s() resuming thread = %"  PRIu64 " result = %s", __FUNCTION__, tid, error.Success() ? "true" : "false");
-    return error;
-}
-
-Error
-NativeProcessLinux::SingleStep(lldb::tid_t tid, uint32_t signo)
-{
-    intptr_t data = 0;
-
-    if (signo != LLDB_INVALID_SIGNAL_NUMBER)
-        data = signo;
-
-    // If hardware single-stepping is not supported, we just do a continue. The breakpoint on the
-    // next instruction has been setup in NativeProcessLinux::Resume.
-    return PtraceWrapper(SupportHardwareSingleStepping() ? PTRACE_SINGLESTEP : PTRACE_CONT,
-            tid, nullptr, (void*)data);
-}
-
-Error
 NativeProcessLinux::GetSignalInfo(lldb::tid_t tid, void *siginfo)
 {
     return PtraceWrapper(PTRACE_GETSIGINFO, tid, nullptr, siginfo);
 }
 
 Error
 NativeProcessLinux::GetEventMessage(lldb::tid_t tid, unsigned long *message)
 {
NativeProcessLinux::ResumeThread(NativeThreadLinux &thread, lldb::StateType state, int signo)
     }
 
     // Request a resume.  We expect this to be synchronous and the system
     // to reflect it is running after this completes.
     switch (state)
     {
     case eStateRunning:
     {
-        thread.SetRunning();
-        const auto resume_result = Resume(thread.GetID(), signo);
+        const auto resume_result = thread.Resume(signo);
         if (resume_result.Success())
             SetState(eStateRunning, true);
         return resume_result;
     }
     case eStateStepping:
     {
-        thread.SetStepping();
-        const auto step_result = SingleStep(thread.GetID(), signo);
+        const auto step_result = thread.SingleStep(signo);
         if (step_result.Success())
             SetState(eStateRunning, true);
         return step_result;
     }
     default:
         if (log)
             log->Printf("NativeProcessLinux::%s Unhandled state %s.",
                     __FUNCTION__, StateAsCString(state));

lldb/trunk/source/Plugins/Process/Linux/NativeThreadLinux.h

 //===-- NativeThreadLinux.h ----------------------------------- -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_NativeThreadLinux_H_
 #define liblldb_NativeThreadLinux_H_
 
 #include "lldb/lldb-private-forward.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 
+#include <sched.h>
+
 #include <map>
 #include <memory>
 #include <string>
 
 namespace lldb_private {
 namespace process_linux {
 
     class NativeProcessLinux;
public:
 
         Error
         RemoveWatchpoint (lldb::addr_t addr) override;
 
     private:
         // ---------------------------------------------------------------------
         // Interface for friend classes
         // ---------------------------------------------------------------------
-        void
-        SetRunning ();
 
-        void
-        SetStepping ();
+        /// Resumes the thread.  If @p signo is anything but
+        /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread.
+        Error
+        Resume(uint32_t signo);
+
+        /// Single steps the thread.  If @p signo is anything but
+        /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread.
+        Error
+        SingleStep(uint32_t signo);
 
         void
         SetStoppedBySignal(uint32_t signo, const siginfo_t *info = nullptr);
 
         /// Return true if the thread is stopped.
         /// If stopped by a signal, indicate the signo in the signo argument.
         /// Otherwise, return LLDB_INVALID_SIGNAL_NUMBER.
         bool
private:
         RequestStop ();
 
         // ---------------------------------------------------------------------
         // Private interface
         // ---------------------------------------------------------------------
         void
         MaybeLogStateChange (lldb::StateType new_state);
 
+        NativeProcessLinux &
+        GetProcess();
+
+        void
+        SetStopped();
+
+        inline void
+        MaybePrepareSingleStepWorkaround();
+
+        inline void
+        MaybeCleanupSingleStepWorkaround();
+
         // ---------------------------------------------------------------------
         // Member Variables
         // ---------------------------------------------------------------------
         lldb::StateType m_state;
         ThreadStopInfo m_stop_info;
         NativeRegisterContextSP m_reg_context_sp;
         std::string m_stop_description;
         using WatchpointIndexMap = std::map<lldb::addr_t, uint32_t>;
         WatchpointIndexMap m_watchpoint_index_map;
+        cpu_set_t m_original_cpu_set; // For single-step workaround.
     };
 
     typedef std::shared_ptr<NativeThreadLinux> NativeThreadLinuxSP;
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeThreadLinux_H_

lldb/trunk/source/Plugins/Process/Linux/NativeThreadLinux.cpp

 //===-- NativeThreadLinux.cpp --------------------------------- -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "NativeThreadLinux.h"
 
 #include <signal.h>
 #include <sstream>
 
 #include "NativeProcessLinux.h"
 #include "NativeRegisterContextLinux.h"
+#include "SingleStepCheck.h"
 
 #include "lldb/Core/Log.h"
 #include "lldb/Core/State.h"
 #include "lldb/Host/HostNativeThread.h"
+#include "lldb/Host/linux/Ptrace.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/lldb-enumerations.h"
 
 #include "llvm/ADT/SmallString.h"
 
 #include "Plugins/Process/POSIX/CrashReason.h"
 
 #include <sys/syscall.h>
if (wp == m_watchpoint_index_map.end())
         return Error ();
     uint32_t wp_index = wp->second;
     m_watchpoint_index_map.erase(wp);
     if (GetRegisterContext()->ClearHardwareWatchpoint(wp_index))
         return Error ();
     return Error ("Clearing hardware watchpoint failed.");
 }
 
-void
-NativeThreadLinux::SetRunning ()
+Error
+NativeThreadLinux::Resume(uint32_t signo)
 {
     const StateType new_state = StateType::eStateRunning;
     MaybeLogStateChange (new_state);
     m_state = new_state;
 
     m_stop_info.reason = StopReason::eStopReasonNone;
     m_stop_description.clear();
 
     // If watchpoints have been set, but none on this thread,
     // then this is a new thread. So set all existing watchpoints.
     if (m_watchpoint_index_map.empty())
     {
-        const auto process_sp = GetProcess();
-        if (process_sp)
-        {
-            const auto &watchpoint_map = process_sp->GetWatchpointMap();
-            if (watchpoint_map.empty()) return;
-            GetRegisterContext()->ClearAllHardwareWatchpoints();
-            for (const auto &pair : watchpoint_map)
-            {
-                const auto& wp = pair.second;
-                SetWatchpoint(wp.m_addr, wp.m_size, wp.m_watch_flags, wp.m_hardware);
-            }
-        }
+        NativeProcessLinux &process = GetProcess();
+
+        const auto &watchpoint_map = process.GetWatchpointMap();
+            const auto &wp = pair.second;
+
+    intptr_t data = 0;
+
+    if (signo != LLDB_INVALID_SIGNAL_NUMBER)
+        data = signo;
+
+    return NativeProcessLinux::PtraceWrapper(PTRACE_CONT, GetID(), nullptr, reinterpret_cast<void *>(data));
+}
+
+void
+NativeThreadLinux::MaybePrepareSingleStepWorkaround()
+{
+    if (!SingleStepWorkaroundNeeded())
+        return;
+
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
+
+    if (sched_getaffinity(static_cast<::pid_t>(m_tid), sizeof m_original_cpu_set, &m_original_cpu_set) != 0)
+    {
+        // This should really not fail. But, just in case...
+        if (log)
+        {
+            Error error(errno, eErrorTypePOSIX);
+            log->Printf("NativeThreadLinux::%s Unable to get cpu affinity for thread %" PRIx64 ": %s", __FUNCTION__,
+                        m_tid, error.AsCString());
+        }
+        return;
+    }
+
+    cpu_set_t set;
+    CPU_ZERO(&set);
+    CPU_SET(0, &set);
+    if (sched_setaffinity(static_cast<::pid_t>(m_tid), sizeof set, &set) != 0 && log)
+    {
+        // This may fail in very locked down systems, if the thread is not allowed to run on
+        // cpu 0. If that happens, only thing we can do is it log it and continue...
+        Error error(errno, eErrorTypePOSIX);
+        log->Printf("NativeThreadLinux::%s Unable to set cpu affinity for thread %" PRIx64 ": %s", __FUNCTION__, m_tid,
+                    error.AsCString());
     }
 }
 
 void
-NativeThreadLinux::SetStepping ()
+NativeThreadLinux::MaybeCleanupSingleStepWorkaround()
+{
+    if (!SingleStepWorkaroundNeeded())
+        return;
+
+    if (sched_setaffinity(static_cast<::pid_t>(m_tid), sizeof m_original_cpu_set, &m_original_cpu_set) != 0)
+    {
+        Error error(errno, eErrorTypePOSIX);
+        Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
+        log->Printf("NativeThreadLinux::%s Unable to reset cpu affinity for thread %" PRIx64 ": %s", __FUNCTION__,
+                    m_tid, error.AsCString());
+    }
+}
+
+Error
+NativeThreadLinux::SingleStep(uint32_t signo)
 {
     const StateType new_state = StateType::eStateStepping;
     MaybeLogStateChange (new_state);
     m_state = new_state;
-
     m_stop_info.reason = StopReason::eStopReasonNone;
+
+    MaybePrepareSingleStepWorkaround();
+
+    intptr_t data = 0;
+    if (signo != LLDB_INVALID_SIGNAL_NUMBER)
+        data = signo;
+
+    // If hardware single-stepping is not supported, we just do a continue. The breakpoint on the
+    // next instruction has been setup in NativeProcessLinux::Resume.
+    return NativeProcessLinux::PtraceWrapper(GetProcess().SupportHardwareSingleStepping() ? PTRACE_SINGLESTEP
+                                                                                          : PTRACE_CONT,
+                                             m_tid, nullptr, reinterpret_cast<void *>(data));
 }
 
 void
 NativeThreadLinux::SetStoppedBySignal(uint32_t signo, const siginfo_t *info)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
     if (log)
         log->Printf ("NativeThreadLinux::%s called with signal 0x%02" PRIx32, __FUNCTION__, signo);
 
-    const StateType new_state = StateType::eStateStopped;
-    MaybeLogStateChange (new_state);
-    m_state = new_state;
+    SetStopped();
 
     m_stop_info.reason = StopReason::eStopReasonSignal;
     m_stop_info.details.signal.signo = signo;
 
     m_stop_description.clear();
     if (info)
     {
         switch (signo)
NativeThreadLinux::IsStopped (int *signo)
     {
         *signo = m_stop_info.details.signal.signo;
     }
 
     // Regardless, we are stopped.
     return true;
 }
 
+void
+NativeThreadLinux::SetStopped()
+{
+    if (m_state == StateType::eStateStepping)
+        MaybeCleanupSingleStepWorkaround();
+
+    const StateType new_state = StateType::eStateStopped;
+    MaybeLogStateChange(new_state);
+    m_state = new_state;
+    m_stop_description.clear();
+}
 
 void
 NativeThreadLinux::SetStoppedByExec ()
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
     if (log)
         log->Printf ("NativeThreadLinux::%s()", __FUNCTION__);
 
-    const StateType new_state = StateType::eStateStopped;
-    MaybeLogStateChange (new_state);
-    m_state = new_state;
+    SetStopped();
 
     m_stop_info.reason = StopReason::eStopReasonExec;
     m_stop_info.details.signal.signo = SIGSTOP;
 }
 
 void
 NativeThreadLinux::SetStoppedByBreakpoint ()
 {
-    const StateType new_state = StateType::eStateStopped;
-    MaybeLogStateChange (new_state);
-    m_state = new_state;
+    SetStopped();
 
     m_stop_info.reason = StopReason::eStopReasonBreakpoint;
     m_stop_info.details.signal.signo = SIGTRAP;
     m_stop_description.clear();
 }
 
 void
 NativeThreadLinux::SetStoppedByWatchpoint (uint32_t wp_index)
 {
-    const StateType new_state = StateType::eStateStopped;
-    MaybeLogStateChange (new_state);
-    m_state = new_state;
-    m_stop_description.clear ();
+    SetStopped();
 
     lldbassert(wp_index != LLDB_INVALID_INDEX32 &&
                "wp_index cannot be invalid");
 
     std::ostringstream ostr;
     ostr << GetRegisterContext()->GetWatchpointAddress(wp_index) << " ";
     ostr << wp_index;
 

 {
     return GetState () == StateType::eStateStopped &&
         m_stop_info.reason == StopReason::eStopReasonWatchpoint;
 }
 
 void
 NativeThreadLinux::SetStoppedByTrace ()
 {
-    const StateType new_state = StateType::eStateStopped;
-    MaybeLogStateChange (new_state);
-    m_state = new_state;
+    SetStopped();
 
     m_stop_info.reason = StopReason::eStopReasonTrace;
     m_stop_info.details.signal.signo = SIGTRAP;
 }
 
 void
 NativeThreadLinux::SetStoppedWithNoReason ()
 {
-    const StateType new_state = StateType::eStateStopped;
-    MaybeLogStateChange (new_state);
-    m_state = new_state;
+    SetStopped();
 
     m_stop_info.reason = StopReason::eStopReasonNone;
     m_stop_info.details.signal.signo = 0;
 }
 
 void
 NativeThreadLinux::SetExited ()
 {
     const StateType new_state = StateType::eStateExited;
     MaybeLogStateChange (new_state);
     m_state = new_state;
 
     m_stop_info.reason = StopReason::eStopReasonThreadExiting;
 }
 
 Error
 NativeThreadLinux::RequestStop ()
 {
     Log* log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
 
-    const auto process_sp = GetProcess();
-    if (! process_sp)
-        return Error("Process is null.");
+    NativeProcessLinux &process = GetProcess();
 
-    lldb::pid_t pid = process_sp->GetID();
+    lldb::pid_t pid = process.GetID();
     lldb::tid_t tid = GetID();
 
     if (log)
         log->Printf ("NativeThreadLinux::%s requesting thread stop(pid: %" PRIu64 ", tid: %" PRIu64 ")", __FUNCTION__, pid, tid);
 
     Error err;
     errno = 0;
     if (::tgkill (pid, tid, SIGSTOP) != 0)
if (new_state == old_state)
         return;
 
     NativeProcessProtocolSP m_process_sp = m_process_wp.lock ();
     lldb::pid_t pid = m_process_sp ? m_process_sp->GetID () : LLDB_INVALID_PROCESS_ID;
 
     // Log it.
     log->Printf ("NativeThreadLinux: thread (pid=%" PRIu64 ", tid=%" PRIu64 ") changing from state %s to %s", pid, GetID (), StateAsCString (old_state), StateAsCString (new_state));
 }
+
+NativeProcessLinux &
+NativeThreadLinux::GetProcess()
+{
+    auto process_sp = std::static_pointer_cast<NativeProcessLinux>(NativeThreadProtocol::GetProcess());
+    assert(process_sp);
+    return *process_sp;
+}

lldb/trunk/source/Plugins/Process/Linux/SingleStepCheck.h

+//===-- SingleStepCheck.h ------------------------------------- -*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_SingleStepCheck_H_
+#define liblldb_SingleStepCheck_H_
+
+namespace lldb_private
+{
+namespace process_linux
+{
+
+namespace impl
+{
+extern bool
+SingleStepWorkaroundNeeded();
+}
+
+// arm64 linux had a bug which prevented single-stepping and watchpoints from working on non-boot
+// cpus, due to them being incorrectly initialized after coming out of suspend.  This issue is
+// particularly affecting android M, which uses suspend ("doze mode") quite aggressively. This
+// code detects that situation and makes single-stepping work by doing all the step operations on
+// the boot cpu.
+//
+// The underlying issue has been fixed in android N and linux 4.4. This code can be removed once
+// these systems become obsolete.
+inline bool
+SingleStepWorkaroundNeeded()
+{
+    static bool value = impl::SingleStepWorkaroundNeeded();
+    return value;
+}
+} // end namespace process_linux
+} // end namespace lldb_private
+
+#endif // #ifndef liblldb_SingleStepCheck_H_

lldb/trunk/source/Plugins/Process/Linux/SingleStepCheck.cpp

+//===-- SingleStepCheck.cpp ----------------------------------- -*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SingleStepCheck.h"
+
+#include <sched.h>
+#include <signal.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "NativeProcessLinux.h"
+
+#include "llvm/Support/Compiler.h"
+
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Host/linux/Ptrace.h"
+
+using namespace lldb_private::process_linux;
+
+#if defined(__arm64__) || defined(__aarch64__)
+namespace
+{
+
+void LLVM_ATTRIBUTE_NORETURN
+Child()
+{
+    if (ptrace(PTRACE_TRACEME, 0, nullptr, nullptr) == -1)
+        _exit(1);
+
+    // We just do an endless loop SIGSTOPPING ourselves until killed. The tracer will fiddle with our cpu
+    // affinities and monitor the behaviour.
+    for (;;)
+    {
+        raise(SIGSTOP);
+
+        // Generate a bunch of instructions here, so that a single-step does not land in the
+        // raise() accidentally. If single-stepping works, we will be spinning in this loop. If
+        // it doesn't, we'll land in the raise() call above.
+        for (volatile unsigned i = 0; i < CPU_SETSIZE; ++i)
+            ;
+    }
+}
+
+struct ChildDeleter
+{
+    ::pid_t pid;
+
+    ~ChildDeleter()
+    {
+        int status;
+        kill(pid, SIGKILL);            // Kill the child.
+        waitpid(pid, &status, __WALL); // Pick up the remains.
+    }
+};
+
+} // end anonymous namespace
+
+bool
+impl::SingleStepWorkaroundNeeded()
+{
+    // We shall spawn a child, and use it to verify the debug capabilities of the cpu. We shall
+    // iterate through the cpus, bind the child to each one in turn, and verify that
+    // single-stepping works on that cpu. A workaround is needed if we find at least one broken
+    // cpu.
+
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
+    Error error;
+    ::pid_t child_pid = fork();
+    if (child_pid == -1)
+    {
+        if (log)
+        {
+            error.SetErrorToErrno();
+            log->Printf("%s failed to fork(): %s", __FUNCTION__, error.AsCString());
+        }
+        return false;
+    }
+    if (child_pid == 0)
+        Child();
+
+    ChildDeleter child_deleter{child_pid};
+    cpu_set_t available_cpus;
+    if (sched_getaffinity(child_pid, sizeof available_cpus, &available_cpus) == -1)
+    {
+        if (log)
+        {
+            error.SetErrorToErrno();
+            log->Printf("%s failed to get available cpus: %s", __FUNCTION__, error.AsCString());
+        }
+        return false;
+    }
+
+    int status;
+    ::pid_t wpid = waitpid(child_pid, &status, __WALL);
+    if (wpid != child_pid || !WIFSTOPPED(status))
+    {
+        if (log)
+        {
+            error.SetErrorToErrno();
+            log->Printf("%s waitpid() failed (status = %x): %s", __FUNCTION__, status, error.AsCString());
+        }
+        return false;
+    }
+
+    unsigned cpu;
+    for (cpu = 0; cpu < CPU_SETSIZE; ++cpu)
+    {
+        if (!CPU_ISSET(cpu, &available_cpus))
+            continue;
+
+        cpu_set_t cpus;
+        CPU_ZERO(&cpus);
+        CPU_SET(cpu, &cpus);
+        if (sched_setaffinity(child_pid, sizeof cpus, &cpus) == -1)
+        {
+            if (log)
+            {
+                error.SetErrorToErrno();
+                log->Printf("%s failed to switch to cpu %u: %s", __FUNCTION__, cpu, error.AsCString());
+            }
+            continue;
+        }
+
+        int status;
+        error = NativeProcessLinux::PtraceWrapper(PTRACE_SINGLESTEP, child_pid);
+        if (error.Fail())
+        {
+            if (log)
+                log->Printf("%s single step failed: %s", __FUNCTION__, error.AsCString());
+            break;
+        }
+
+        wpid = waitpid(child_pid, &status, __WALL);
+        if (wpid != child_pid || !WIFSTOPPED(status))
+        {
+            if (log)
+            {
+                error.SetErrorToErrno();
+                log->Printf("%s waitpid() failed (status = %x): %s", __FUNCTION__, status, error.AsCString());
+            }
+            break;
+        }
+        if (WSTOPSIG(status) != SIGTRAP)
+        {
+            if (log)
+                log->Printf("%s single stepping on cpu %d failed with status %x", __FUNCTION__, cpu, status);
+            break;
+        }
+    }
+
+    // cpu is either the index of the first broken cpu, or CPU_SETSIZE.
+    if (cpu == 0)
+    {
+        if (log)
+            log->Printf("%s SINGLE STEPPING ON FIRST CPU IS NOT WORKING. DEBUGGING LIKELY TO BE UNRELIABLE.",
+                        __FUNCTION__);
+        // No point in trying to fiddle with the affinities, just give it our best shot and see how it goes.
+        return false;
+    }
+
+    return cpu != CPU_SETSIZE;
+}
+
+#else // !arm64
+bool
+impl::SingleStepWorkaroundNeeded()
+{
+    return false;
+}
+#endif