[vm, profiler] Don't tear down sample buffers while there are pending signal handlers.

TEST=dartfuzz
Bug: #42401
Bug: #52052
Bug: #60809
Change-Id: Ic61968fd312de6f84f2a064be18cbed8f2c68e5d
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/456820
Commit-Queue: Ryan Macnak <[email protected]>
Reviewed-by: Alexander Aprelev <[email protected]>

Author: rmacnak-google

runtime/vm/thread_interrupter_android.cc

@@ -29,6 +29,60 @@ namespace dart {
 
 DECLARE_FLAG(bool, trace_thread_interrupter);
 
+class SignalState : public AllStatic {
+ public:
+  static bool Start() {
+    uword expected = state_.load(std::memory_order_relaxed);
+    uword desired;
+    do {
+      if (!Enabled::decode(expected)) return false;
+      desired = Pending::update(Pending::decode(expected) + 1, expected);
+    } while (!state_.compare_exchange_weak(expected, desired,
+                                           std::memory_order_relaxed));
+    return true;
+  }
+
+  static void End() {
+    uword expected = state_.load(std::memory_order_relaxed);
+    uword desired;
+    do {
+      intptr_t pending = Pending::decode(expected);
+      ASSERT(pending > 0);
+      desired = Pending::update(pending - 1, expected);
+    } while (!state_.compare_exchange_weak(expected, desired,
+                                           std::memory_order_relaxed));
+  }
+
+  static void Enable() {
+    uword expected = state_.load(std::memory_order_relaxed);
+    ASSERT(expected == (Enabled::encode(false) | Pending::encode(0)));
+    uword desired = Enabled::encode(true) | Pending::encode(0);
+    bool success = state_.compare_exchange_strong(expected, desired,
+                                                  std::memory_order_relaxed);
+    ASSERT(success);
+  }
+
+  static void Disable() {
+    ASSERT(Enabled::decode(state_.load(std::memory_order_relaxed)));
+    uword expected;
+    uword desired = Enabled::encode(false) | Pending::encode(0);
+    do {
+      // Failed CAS updates [expected], recompute.
+      expected = Enabled::encode(true) | Pending::encode(0);
+    } while (!state_.compare_exchange_weak(expected, desired,
+                                           std::memory_order_relaxed));
+  }
+
+ private:
+  using Enabled = BitField<uword, bool, 0, 1>;
+  using Pending =
+      BitField<uword, intptr_t, Enabled::kNextBit, kBitsPerWord - 1>;
+  static std::atomic<uword> state_;
+};
+
+std::atomic<uword> SignalState::state_ = {Enabled::encode(false) |
+                                          Pending::encode(0)};
+
 namespace {
 #if defined(USE_SIGNAL_HANDLER_TRAMPOLINE)
 extern "C" {
@@ -41,6 +95,9 @@ void ThreadInterruptSignalHandler(int signal, siginfo_t* info, void* context_) {
   if (thread == nullptr) {
     return;
   }
+  if (!SignalState::Start()) {
+    return;
+  }
   ThreadInterruptScope signal_handler_scope;
   // Extract thread state.
   ucontext_t* context = reinterpret_cast<ucontext_t*>(context_);
@@ -52,6 +109,7 @@ void ThreadInterruptSignalHandler(int signal, siginfo_t* info, void* context_) {
   its.dsp = SignalHandler::GetDartStackPointer(mcontext);
   its.lr = SignalHandler::GetLinkRegister(mcontext);
   Profiler::SampleThread(thread, its);
+  SignalState::End();
 }
 #if defined(USE_SIGNAL_HANDLER_TRAMPOLINE)
 }  // extern "C"
@@ -81,9 +139,11 @@ void ThreadInterrupter::InstallSignalHandler() {
 #else
   SignalHandler::Install(&ThreadInterruptSignalHandler);
 #endif
+  SignalState::Enable();
 }
 
 void ThreadInterrupter::RemoveSignalHandler() {
+  SignalState::Disable();
   SignalHandler::Remove();
 }
 

runtime/vm/thread_interrupter_linux.cc

@@ -19,6 +19,60 @@ namespace dart {
 
 DECLARE_FLAG(bool, trace_thread_interrupter);
 
+class SignalState : public AllStatic {
+ public:
+  static bool Start() {
+    uword expected = state_.load(std::memory_order_relaxed);
+    uword desired;
+    do {
+      if (!Enabled::decode(expected)) return false;
+      desired = Pending::update(Pending::decode(expected) + 1, expected);
+    } while (!state_.compare_exchange_weak(expected, desired,
+                                           std::memory_order_relaxed));
+    return true;
+  }
+
+  static void End() {
+    uword expected = state_.load(std::memory_order_relaxed);
+    uword desired;
+    do {
+      intptr_t pending = Pending::decode(expected);
+      ASSERT(pending > 0);
+      desired = Pending::update(pending - 1, expected);
+    } while (!state_.compare_exchange_weak(expected, desired,
+                                           std::memory_order_relaxed));
+  }
+
+  static void Enable() {
+    uword expected = state_.load(std::memory_order_relaxed);
+    ASSERT(expected == (Enabled::encode(false) | Pending::encode(0)));
+    uword desired = Enabled::encode(true) | Pending::encode(0);
+    bool success = state_.compare_exchange_strong(expected, desired,
+                                                  std::memory_order_relaxed);
+    ASSERT(success);
+  }
+
+  static void Disable() {
+    ASSERT(Enabled::decode(state_.load(std::memory_order_relaxed)));
+    uword expected;
+    uword desired = Enabled::encode(false) | Pending::encode(0);
+    do {
+      // Failed CAS updates [expected], recompute.
+      expected = Enabled::encode(true) | Pending::encode(0);
+    } while (!state_.compare_exchange_weak(expected, desired,
+                                           std::memory_order_relaxed));
+  }
+
+ private:
+  using Enabled = BitField<uword, bool, 0, 1>;
+  using Pending =
+      BitField<uword, intptr_t, Enabled::kNextBit, kBitsPerWord - 1>;
+  static std::atomic<uword> state_;
+};
+
+std::atomic<uword> SignalState::state_ = {Enabled::encode(false) |
+                                          Pending::encode(0)};
+
 class ThreadInterrupterLinux : public AllStatic {
  public:
   static void ThreadInterruptSignalHandler(int signal,
@@ -31,6 +85,9 @@ class ThreadInterrupterLinux : public AllStatic {
     if (thread == nullptr) {
       return;
     }
+    if (!SignalState::Start()) {
+      return;
+    }
     ThreadInterruptScope signal_handler_scope;
     // Extract thread state.
     ucontext_t* context = reinterpret_cast<ucontext_t*>(context_);
@@ -42,6 +99,7 @@ class ThreadInterrupterLinux : public AllStatic {
     its.dsp = SignalHandler::GetDartStackPointer(mcontext);
     its.lr = SignalHandler::GetLinkRegister(mcontext);
     Profiler::SampleThread(thread, its);
+    SignalState::End();
   }
 };
 
@@ -56,9 +114,11 @@ void ThreadInterrupter::InterruptThread(OSThread* thread) {
 
 void ThreadInterrupter::InstallSignalHandler() {
   SignalHandler::Install(&ThreadInterrupterLinux::ThreadInterruptSignalHandler);
+  SignalState::Enable();
 }
 
 void ThreadInterrupter::RemoveSignalHandler() {
+  SignalState::Disable();
   SignalHandler::Remove();
 }