forked from OSchip/llvm-project
363 lines
11 KiB
C++
363 lines
11 KiB
C++
//===-- sanitizer_stoptheworld_netbsd_libcdep.cpp -------------------------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// See sanitizer_stoptheworld.h for details.
|
|
// This implementation was inspired by Markus Gutschke's linuxthreads.cc.
|
|
//
|
|
// This is a NetBSD variation of Linux stoptheworld implementation
|
|
// See sanitizer_stoptheworld_linux_libcdep.cpp for code comments.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "sanitizer_platform.h"
|
|
|
|
#if SANITIZER_NETBSD
|
|
|
|
#include "sanitizer_stoptheworld.h"
|
|
|
|
#include "sanitizer_atomic.h"
|
|
#include "sanitizer_platform_limits_posix.h"
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/ptrace.h>
|
|
#include <sys/uio.h>
|
|
#include <sys/wait.h>
|
|
|
|
#include <machine/reg.h>
|
|
|
|
#include <elf.h>
|
|
#include <errno.h>
|
|
#include <sched.h>
|
|
#include <signal.h>
|
|
#include <stddef.h>
|
|
|
|
#define internal_sigaction_norestorer internal_sigaction
|
|
|
|
#include "sanitizer_common.h"
|
|
#include "sanitizer_flags.h"
|
|
#include "sanitizer_libc.h"
|
|
#include "sanitizer_linux.h"
|
|
#include "sanitizer_mutex.h"
|
|
#include "sanitizer_placement_new.h"
|
|
|
|
namespace __sanitizer {
|
|
|
|
class SuspendedThreadsListNetBSD final : public SuspendedThreadsList {
|
|
public:
|
|
SuspendedThreadsListNetBSD() { thread_ids_.reserve(1024); }
|
|
|
|
tid_t GetThreadID(uptr index) const;
|
|
uptr ThreadCount() const;
|
|
bool ContainsTid(tid_t thread_id) const;
|
|
void Append(tid_t tid);
|
|
|
|
PtraceRegistersStatus GetRegistersAndSP(uptr index,
|
|
InternalMmapVector<uptr> *buffer,
|
|
uptr *sp) const;
|
|
|
|
private:
|
|
InternalMmapVector<tid_t> thread_ids_;
|
|
};
|
|
|
|
struct TracerThreadArgument {
|
|
StopTheWorldCallback callback;
|
|
void *callback_argument;
|
|
Mutex mutex;
|
|
atomic_uintptr_t done;
|
|
uptr parent_pid;
|
|
};
|
|
|
|
class ThreadSuspender {
|
|
public:
|
|
explicit ThreadSuspender(pid_t pid, TracerThreadArgument *arg)
|
|
: arg(arg), pid_(pid) {
|
|
CHECK_GE(pid, 0);
|
|
}
|
|
bool SuspendAllThreads();
|
|
void ResumeAllThreads();
|
|
void KillAllThreads();
|
|
SuspendedThreadsListNetBSD &suspended_threads_list() {
|
|
return suspended_threads_list_;
|
|
}
|
|
TracerThreadArgument *arg;
|
|
|
|
private:
|
|
SuspendedThreadsListNetBSD suspended_threads_list_;
|
|
pid_t pid_;
|
|
};
|
|
|
|
void ThreadSuspender::ResumeAllThreads() {
|
|
int pterrno;
|
|
if (!internal_iserror(internal_ptrace(PT_DETACH, pid_, (void *)(uptr)1, 0),
|
|
&pterrno)) {
|
|
VReport(2, "Detached from process %d.\n", pid_);
|
|
} else {
|
|
VReport(1, "Could not detach from process %d (errno %d).\n", pid_, pterrno);
|
|
}
|
|
}
|
|
|
|
void ThreadSuspender::KillAllThreads() {
|
|
internal_ptrace(PT_KILL, pid_, nullptr, 0);
|
|
}
|
|
|
|
bool ThreadSuspender::SuspendAllThreads() {
|
|
int pterrno;
|
|
if (internal_iserror(internal_ptrace(PT_ATTACH, pid_, nullptr, 0),
|
|
&pterrno)) {
|
|
Printf("Could not attach to process %d (errno %d).\n", pid_, pterrno);
|
|
return false;
|
|
}
|
|
|
|
int status;
|
|
uptr waitpid_status;
|
|
HANDLE_EINTR(waitpid_status, internal_waitpid(pid_, &status, 0));
|
|
|
|
VReport(2, "Attached to process %d.\n", pid_);
|
|
|
|
#ifdef PT_LWPNEXT
|
|
struct ptrace_lwpstatus pl;
|
|
int op = PT_LWPNEXT;
|
|
#else
|
|
struct ptrace_lwpinfo pl;
|
|
int op = PT_LWPINFO;
|
|
#endif
|
|
|
|
pl.pl_lwpid = 0;
|
|
|
|
int val;
|
|
while ((val = internal_ptrace(op, pid_, (void *)&pl, sizeof(pl))) != -1 &&
|
|
pl.pl_lwpid != 0) {
|
|
suspended_threads_list_.Append(pl.pl_lwpid);
|
|
VReport(2, "Appended thread %d in process %d.\n", pl.pl_lwpid, pid_);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Pointer to the ThreadSuspender instance for use in signal handler.
|
|
static ThreadSuspender *thread_suspender_instance = nullptr;
|
|
|
|
// Synchronous signals that should not be blocked.
|
|
static const int kSyncSignals[] = {SIGABRT, SIGILL, SIGFPE, SIGSEGV,
|
|
SIGBUS, SIGXCPU, SIGXFSZ};
|
|
|
|
static void TracerThreadDieCallback() {
|
|
ThreadSuspender *inst = thread_suspender_instance;
|
|
if (inst && stoptheworld_tracer_pid == internal_getpid()) {
|
|
inst->KillAllThreads();
|
|
thread_suspender_instance = nullptr;
|
|
}
|
|
}
|
|
|
|
// Signal handler to wake up suspended threads when the tracer thread dies.
|
|
static void TracerThreadSignalHandler(int signum, __sanitizer_siginfo *siginfo,
|
|
void *uctx) {
|
|
SignalContext ctx(siginfo, uctx);
|
|
Printf("Tracer caught signal %d: addr=0x%zx pc=0x%zx sp=0x%zx\n", signum,
|
|
ctx.addr, ctx.pc, ctx.sp);
|
|
ThreadSuspender *inst = thread_suspender_instance;
|
|
if (inst) {
|
|
if (signum == SIGABRT)
|
|
inst->KillAllThreads();
|
|
else
|
|
inst->ResumeAllThreads();
|
|
RAW_CHECK(RemoveDieCallback(TracerThreadDieCallback));
|
|
thread_suspender_instance = nullptr;
|
|
atomic_store(&inst->arg->done, 1, memory_order_relaxed);
|
|
}
|
|
internal__exit((signum == SIGABRT) ? 1 : 2);
|
|
}
|
|
|
|
// Size of alternative stack for signal handlers in the tracer thread.
|
|
static const int kHandlerStackSize = 8192;
|
|
|
|
// This function will be run as a cloned task.
|
|
static int TracerThread(void *argument) {
|
|
TracerThreadArgument *tracer_thread_argument =
|
|
(TracerThreadArgument *)argument;
|
|
|
|
// Check if parent is already dead.
|
|
if (internal_getppid() != tracer_thread_argument->parent_pid)
|
|
internal__exit(4);
|
|
|
|
// Wait for the parent thread to finish preparations.
|
|
tracer_thread_argument->mutex.Lock();
|
|
tracer_thread_argument->mutex.Unlock();
|
|
|
|
RAW_CHECK(AddDieCallback(TracerThreadDieCallback));
|
|
|
|
ThreadSuspender thread_suspender(internal_getppid(), tracer_thread_argument);
|
|
// Global pointer for the signal handler.
|
|
thread_suspender_instance = &thread_suspender;
|
|
|
|
// Alternate stack for signal handling.
|
|
InternalMmapVector<char> handler_stack_memory(kHandlerStackSize);
|
|
stack_t handler_stack;
|
|
internal_memset(&handler_stack, 0, sizeof(handler_stack));
|
|
handler_stack.ss_sp = handler_stack_memory.data();
|
|
handler_stack.ss_size = kHandlerStackSize;
|
|
internal_sigaltstack(&handler_stack, nullptr);
|
|
|
|
// Install our handler for synchronous signals. Other signals should be
|
|
// blocked by the mask we inherited from the parent thread.
|
|
for (uptr i = 0; i < ARRAY_SIZE(kSyncSignals); i++) {
|
|
__sanitizer_sigaction act;
|
|
internal_memset(&act, 0, sizeof(act));
|
|
act.sigaction = TracerThreadSignalHandler;
|
|
act.sa_flags = SA_ONSTACK | SA_SIGINFO;
|
|
internal_sigaction_norestorer(kSyncSignals[i], &act, 0);
|
|
}
|
|
|
|
int exit_code = 0;
|
|
if (!thread_suspender.SuspendAllThreads()) {
|
|
VReport(1, "Failed suspending threads.\n");
|
|
exit_code = 3;
|
|
} else {
|
|
tracer_thread_argument->callback(thread_suspender.suspended_threads_list(),
|
|
tracer_thread_argument->callback_argument);
|
|
thread_suspender.ResumeAllThreads();
|
|
exit_code = 0;
|
|
}
|
|
RAW_CHECK(RemoveDieCallback(TracerThreadDieCallback));
|
|
thread_suspender_instance = nullptr;
|
|
atomic_store(&tracer_thread_argument->done, 1, memory_order_relaxed);
|
|
return exit_code;
|
|
}
|
|
|
|
class ScopedStackSpaceWithGuard {
|
|
public:
|
|
explicit ScopedStackSpaceWithGuard(uptr stack_size) {
|
|
stack_size_ = stack_size;
|
|
guard_size_ = GetPageSizeCached();
|
|
// FIXME: Omitting MAP_STACK here works in current kernels but might break
|
|
// in the future.
|
|
guard_start_ =
|
|
(uptr)MmapOrDie(stack_size_ + guard_size_, "ScopedStackWithGuard");
|
|
CHECK(MprotectNoAccess((uptr)guard_start_, guard_size_));
|
|
}
|
|
~ScopedStackSpaceWithGuard() {
|
|
UnmapOrDie((void *)guard_start_, stack_size_ + guard_size_);
|
|
}
|
|
void *Bottom() const {
|
|
return (void *)(guard_start_ + stack_size_ + guard_size_);
|
|
}
|
|
|
|
private:
|
|
uptr stack_size_;
|
|
uptr guard_size_;
|
|
uptr guard_start_;
|
|
};
|
|
|
|
static __sanitizer_sigset_t blocked_sigset;
|
|
static __sanitizer_sigset_t old_sigset;
|
|
|
|
struct ScopedSetTracerPID {
|
|
explicit ScopedSetTracerPID(uptr tracer_pid) {
|
|
stoptheworld_tracer_pid = tracer_pid;
|
|
stoptheworld_tracer_ppid = internal_getpid();
|
|
}
|
|
~ScopedSetTracerPID() {
|
|
stoptheworld_tracer_pid = 0;
|
|
stoptheworld_tracer_ppid = 0;
|
|
}
|
|
};
|
|
|
|
void StopTheWorld(StopTheWorldCallback callback, void *argument) {
|
|
// Prepare the arguments for TracerThread.
|
|
struct TracerThreadArgument tracer_thread_argument;
|
|
tracer_thread_argument.callback = callback;
|
|
tracer_thread_argument.callback_argument = argument;
|
|
tracer_thread_argument.parent_pid = internal_getpid();
|
|
atomic_store(&tracer_thread_argument.done, 0, memory_order_relaxed);
|
|
const uptr kTracerStackSize = 2 * 1024 * 1024;
|
|
ScopedStackSpaceWithGuard tracer_stack(kTracerStackSize);
|
|
|
|
tracer_thread_argument.mutex.Lock();
|
|
|
|
internal_sigfillset(&blocked_sigset);
|
|
for (uptr i = 0; i < ARRAY_SIZE(kSyncSignals); i++)
|
|
internal_sigdelset(&blocked_sigset, kSyncSignals[i]);
|
|
int rv = internal_sigprocmask(SIG_BLOCK, &blocked_sigset, &old_sigset);
|
|
CHECK_EQ(rv, 0);
|
|
uptr tracer_pid = internal_clone(TracerThread, tracer_stack.Bottom(),
|
|
CLONE_VM | CLONE_FS | CLONE_FILES,
|
|
&tracer_thread_argument);
|
|
internal_sigprocmask(SIG_SETMASK, &old_sigset, 0);
|
|
int local_errno = 0;
|
|
if (internal_iserror(tracer_pid, &local_errno)) {
|
|
VReport(1, "Failed spawning a tracer thread (errno %d).\n", local_errno);
|
|
tracer_thread_argument.mutex.Unlock();
|
|
} else {
|
|
ScopedSetTracerPID scoped_set_tracer_pid(tracer_pid);
|
|
|
|
tracer_thread_argument.mutex.Unlock();
|
|
|
|
while (atomic_load(&tracer_thread_argument.done, memory_order_relaxed) == 0)
|
|
sched_yield();
|
|
|
|
for (;;) {
|
|
uptr waitpid_status = internal_waitpid(tracer_pid, nullptr, __WALL);
|
|
if (!internal_iserror(waitpid_status, &local_errno))
|
|
break;
|
|
if (local_errno == EINTR)
|
|
continue;
|
|
VReport(1, "Waiting on the tracer thread failed (errno %d).\n",
|
|
local_errno);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
tid_t SuspendedThreadsListNetBSD::GetThreadID(uptr index) const {
|
|
CHECK_LT(index, thread_ids_.size());
|
|
return thread_ids_[index];
|
|
}
|
|
|
|
uptr SuspendedThreadsListNetBSD::ThreadCount() const {
|
|
return thread_ids_.size();
|
|
}
|
|
|
|
bool SuspendedThreadsListNetBSD::ContainsTid(tid_t thread_id) const {
|
|
for (uptr i = 0; i < thread_ids_.size(); i++) {
|
|
if (thread_ids_[i] == thread_id)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void SuspendedThreadsListNetBSD::Append(tid_t tid) {
|
|
thread_ids_.push_back(tid);
|
|
}
|
|
|
|
PtraceRegistersStatus SuspendedThreadsListNetBSD::GetRegistersAndSP(
|
|
uptr index, InternalMmapVector<uptr> *buffer, uptr *sp) const {
|
|
lwpid_t tid = GetThreadID(index);
|
|
pid_t ppid = internal_getppid();
|
|
struct reg regs;
|
|
int pterrno;
|
|
bool isErr =
|
|
internal_iserror(internal_ptrace(PT_GETREGS, ppid, ®s, tid), &pterrno);
|
|
if (isErr) {
|
|
VReport(1,
|
|
"Could not get registers from process %d thread %d (errno %d).\n",
|
|
ppid, tid, pterrno);
|
|
return pterrno == ESRCH ? REGISTERS_UNAVAILABLE_FATAL
|
|
: REGISTERS_UNAVAILABLE;
|
|
}
|
|
|
|
*sp = PTRACE_REG_SP(®s);
|
|
buffer->resize(RoundUpTo(sizeof(regs), sizeof(uptr)) / sizeof(uptr));
|
|
internal_memcpy(buffer->data(), ®s, sizeof(regs));
|
|
|
|
return REGISTERS_AVAILABLE;
|
|
}
|
|
|
|
} // namespace __sanitizer
|
|
|
|
#endif
|