sigchainlib/sigchain.cc - platform/art - Gitiles

 /*
  * Copyright (C) 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #ifdef ART_TARGET_ANDROID
 #include <android/log.h>
 #else
 #include <stdarg.h>
 #include <iostream>
 #endif

 #include <dlfcn.h>
 #include <errno.h>
 #include <pthread.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 #include <initializer_list>
 #include <mutex>
 #include <utility>

 #include "sigchain.h"

 #if defined(__APPLE__)
 #define _NSIG NSIG
 #define sighandler_t sig_t

 // Darwin has an #error when ucontext.h is included without _XOPEN_SOURCE defined.
 #define _XOPEN_SOURCE
 #endif

 #include <ucontext.h>

 // libsigchain provides an interception layer for signal handlers, to allow ART and others to give
 // their signal handlers the first stab at handling signals before passing them on to user code.
 //
 // It implements wrapper functions for signal, sigaction, and sigprocmask, and a handler that
 // forwards signals appropriately.
 //
 // In our handler, we start off with all signals blocked, fetch the original signal mask from the
 // passed in ucontext, and then adjust our signal mask appropriately for the user handler.
 //
 // It's somewhat tricky for us to properly handle some flag cases:
 //   SA_NOCLDSTOP and SA_NOCLDWAIT: shouldn't matter, we don't have special handlers for SIGCHLD.
 //   SA_NODEFER: unimplemented, we can manually change the signal mask appropriately.
 //  ~SA_ONSTACK: always silently enable this
 //   SA_RESETHAND: unimplemented, but we can probably do this?
 //  ~SA_RESTART: unimplemented, maybe we can reserve an RT signal, register an empty handler that
 //               doesn't have SA_RESTART, and raise the signal to avoid restarting syscalls that are
 //               expected to be interrupted?

 static void log(const char* format, ...) {
   char buf[256];
   va_list ap;
   va_start(ap, format);
   vsnprintf(buf, sizeof(buf), format, ap);
 #ifdef ART_TARGET_ANDROID
   __android_log_write(ANDROID_LOG_ERROR, "libsigchain", buf);
 #else
   std::cout << buf << "\n";
 #endif
   va_end(ap);
 }

 #define fatal(...) log(__VA_ARGS__); abort()

 static int sigorset(sigset_t* dest, sigset_t* left, sigset_t* right) {
   sigemptyset(dest);
   for (size_t i = 0; i < sizeof(sigset_t) * CHAR_BIT; ++i) {
     if (sigismember(left, i) == 1 || sigismember(right, i) == 1) {
       sigaddset(dest, i);
     }
   }
   return 0;
 }

 namespace art {

 static decltype(&sigaction) linked_sigaction;
 static decltype(&sigprocmask) linked_sigprocmask;

 static pthread_key_t GetHandlingSignalKey() {
   static pthread_key_t key;
   static std::once_flag once;
   std::call_once(once, []() {
     int rc = pthread_key_create(&key, nullptr);
     if (rc != 0) {
       fatal("failed to create sigchain pthread key: %s", strerror(rc));
     }
   });
   return key;
 }

 static bool GetHandlingSignal() {
   void* result = pthread_getspecific(GetHandlingSignalKey());
   return reinterpret_cast<uintptr_t>(result);
 }

 static void SetHandlingSignal(bool value) {
   pthread_setspecific(GetHandlingSignalKey(),
                       reinterpret_cast<void*>(static_cast<uintptr_t>(value)));
 }

 class ScopedHandlingSignal {
  public:
   ScopedHandlingSignal() : original_value_(GetHandlingSignal()) {
   }

   ~ScopedHandlingSignal() {
     SetHandlingSignal(original_value_);
   }

  private:
   bool original_value_;
 };

 class SignalChain {
  public:
   SignalChain() : claimed_(false) {
   }

   bool IsClaimed() {
     return claimed_;
   }

   void Claim(int signo) {
     if (!claimed_) {
       Register(signo);
       claimed_ = true;
     }
   }

   // Register the signal chain with the kernel if needed.
   void Register(int signo) {
     struct sigaction handler_action = {};
     handler_action.sa_sigaction = SignalChain::Handler;
     handler_action.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
     sigfillset(&handler_action.sa_mask);
     linked_sigaction(signo, &handler_action, &action_);
   }

   void SetAction(const struct sigaction* action) {
     action_ = *action;
   }

   struct sigaction GetAction() {
     return action_;
   }

   void AddSpecialHandler(SpecialSignalHandlerFn fn) {
     for (SpecialSignalHandlerFn& slot : special_handlers_) {
       if (slot == nullptr) {
         slot = fn;
         return;
       }
     }

     fatal("too many special signal handlers");
   }

   void RemoveSpecialHandler(SpecialSignalHandlerFn fn) {
     // This isn't thread safe, but it's unlikely to be a real problem.
     size_t len = sizeof(special_handlers_)/sizeof(*special_handlers_);
     for (size_t i = 0; i < len; ++i) {
       if (special_handlers_[i] == fn) {
         for (size_t j = i; j < len - 1; ++j) {
           special_handlers_[j] = special_handlers_[j + 1];
         }
         special_handlers_[len - 1] = nullptr;
         return;
       }
     }

     fatal("failed to find special handler to remove");
   }


   static void Handler(int signo, siginfo_t* siginfo, void*);

  private:
   bool claimed_;
   struct sigaction action_;
   SpecialSignalHandlerFn special_handlers_[2];
 };

 static SignalChain chains[_NSIG];

 class ScopedSignalUnblocker {
  public:
   explicit ScopedSignalUnblocker(const std::initializer_list<int>& signals) {
     sigset_t new_mask;
     sigemptyset(&new_mask);
     for (int signal : signals) {
       sigaddset(&new_mask, signal);
     }
     if (sigprocmask(SIG_UNBLOCK, &new_mask, &previous_mask_) != 0) {
       fatal("failed to unblock signals: %s", strerror(errno));
     }
   }

   ~ScopedSignalUnblocker() {
     if (sigprocmask(SIG_SETMASK, &previous_mask_, nullptr) != 0) {
       fatal("failed to unblock signals: %s", strerror(errno));
     }
   }

  private:
   sigset_t previous_mask_;
 };

 void SignalChain::Handler(int signo, siginfo_t* siginfo, void* ucontext_raw) {
   ScopedHandlingSignal handling_signal;

   // Try the special handlers first.
   // If one of them crashes, we'll reenter this handler and pass that crash onto the user handler.
   if (!GetHandlingSignal()) {
     ScopedSignalUnblocker unblocked { SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGSEGV }; // NOLINT
     SetHandlingSignal(true);

     for (const auto& handler : chains[signo].special_handlers_) {
       if (handler != nullptr && handler(signo, siginfo, ucontext_raw)) {
         return;
       }
     }
   }

   // Forward to the user's signal handler.
   int handler_flags = chains[signo].action_.sa_flags;
   ucontext_t* ucontext = static_cast<ucontext_t*>(ucontext_raw);
   sigset_t mask;
   sigorset(&mask, &ucontext->uc_sigmask, &chains[signo].action_.sa_mask);
   if ((handler_flags & SA_NODEFER)) {
     sigdelset(&mask, signo);
   }
   sigprocmask(SIG_SETMASK, &mask, nullptr);

   if ((handler_flags & SA_SIGINFO)) {
     chains[signo].action_.sa_sigaction(signo, siginfo, ucontext_raw);
   } else {
     auto handler = chains[signo].action_.sa_handler;
     if (handler == SIG_IGN) {
       return;
     } else if (handler == SIG_DFL) {
       fatal("exiting due to SIG_DFL handler for signal %d", signo);
     } else {
       handler(signo);
     }
   }
 }

 extern "C" int sigaction(int signal, const struct sigaction* new_action, struct sigaction* old_action) {
   // If this signal has been claimed as a signal chain, record the user's
   // action but don't pass it on to the kernel.
   // Note that we check that the signal number is in range here.  An out of range signal
   // number should behave exactly as the libc sigaction.
   if (signal < 0 || signal >= _NSIG) {
     errno = EINVAL;
     return -1;
   }

   if (chains[signal].IsClaimed()) {
     struct sigaction saved_action = chains[signal].GetAction();
     if (new_action != nullptr) {
       chains[signal].SetAction(new_action);
     }
     if (old_action != nullptr) {
       *old_action = saved_action;
     }
     return 0;
   }

   // Will only get here if the signal chain has not been claimed.  We want
   // to pass the sigaction on to the kernel via the real sigaction in libc.
   InitializeSignalChain();
   return linked_sigaction(signal, new_action, old_action);
 }

 extern "C" sighandler_t signal(int signo, sighandler_t handler) {
   if (signo < 0 || signo > _NSIG) {
     errno = EINVAL;
     return SIG_ERR;
   }

   struct sigaction sa = {};
   sigemptyset(&sa.sa_mask);
   sa.sa_handler = handler;
   sa.sa_flags = SA_RESTART | SA_ONSTACK;
   sighandler_t oldhandler;

   // If this signal has been claimed as a signal chain, record the user's
   // action but don't pass it on to the kernel.
   if (chains[signo].IsClaimed()) {
     oldhandler = reinterpret_cast<sighandler_t>(chains[signo].GetAction().sa_handler);
     chains[signo].SetAction(&sa);
     return oldhandler;
   }

   // Will only get here if the signal chain has not been claimed.  We want
   // to pass the sigaction on to the kernel via the real sigaction in libc.
   InitializeSignalChain();
   if (linked_sigaction(signo, &sa, &sa) == -1) {
     return SIG_ERR;
   }

   return reinterpret_cast<sighandler_t>(sa.sa_handler);
 }

 #if !defined(__LP64__)
 extern "C" sighandler_t bsd_signal(int signo, sighandler_t handler) {
   return signal(signo, handler);
 }
 #endif

 extern "C" int sigprocmask(int how, const sigset_t* bionic_new_set, sigset_t* bionic_old_set) {
   // When inside a signal handler, forward directly to the actual sigprocmask.
   if (GetHandlingSignal()) {
     return linked_sigprocmask(how, bionic_new_set, bionic_old_set);
   }

   const sigset_t* new_set_ptr = bionic_new_set;
   sigset_t tmpset;
   if (bionic_new_set != nullptr) {
     tmpset = *bionic_new_set;

     if (how == SIG_BLOCK) {
       // Don't allow claimed signals in the mask.  If a signal chain has been claimed
       // we can't allow the user to block that signal.
       for (int i = 0 ; i < _NSIG; ++i) {
         if (chains[i].IsClaimed() && sigismember(&tmpset, i)) {
           sigdelset(&tmpset, i);
         }
       }
     }
     new_set_ptr = &tmpset;
   }

   InitializeSignalChain();
   return linked_sigprocmask(how, new_set_ptr, bionic_old_set);
 }

 extern "C" void InitializeSignalChain() {
   // Warning.
   // Don't call this from within a signal context as it makes calls to
   // dlsym.  Calling into the dynamic linker will result in locks being
   // taken and if it so happens that a signal occurs while one of these
   // locks is already taken, dlsym will block trying to reenter a
   // mutex and we will never get out of it.
   static bool initialized = false;
   if (initialized) {
     // Don't initialize twice.
     return;
   }

   void* linked_sigaction_sym = dlsym(RTLD_NEXT, "sigaction");
   if (linked_sigaction_sym == nullptr) {
     linked_sigaction_sym = dlsym(RTLD_DEFAULT, "sigaction");
     if (linked_sigaction_sym == nullptr ||
         linked_sigaction_sym == reinterpret_cast<void*>(sigaction)) {
       fatal("Unable to find next sigaction in signal chain");
     }
   }

   void* linked_sigprocmask_sym = dlsym(RTLD_NEXT, "sigprocmask");
   if (linked_sigprocmask_sym == nullptr) {
     linked_sigprocmask_sym = dlsym(RTLD_DEFAULT, "sigprocmask");
     if (linked_sigprocmask_sym == nullptr ||
         linked_sigprocmask_sym == reinterpret_cast<void*>(sigprocmask)) {
       fatal("Unable to find next sigprocmask in signal chain");
     }
   }

   linked_sigaction = reinterpret_cast<decltype(linked_sigaction)>(linked_sigaction_sym);
   linked_sigprocmask = reinterpret_cast<decltype(linked_sigprocmask)>(linked_sigprocmask_sym);
   initialized = true;
 }

 extern "C" void AddSpecialSignalHandlerFn(int signal, SpecialSignalHandlerFn fn) {
   if (signal <= 0 || signal >= _NSIG) {
     fatal("Invalid signal %d", signal);
   }

   // Set the managed_handler.
   chains[signal].AddSpecialHandler(fn);
   chains[signal].Claim(signal);
 }

 extern "C" void RemoveSpecialSignalHandlerFn(int signal, SpecialSignalHandlerFn fn) {
   if (signal <= 0 || signal >= _NSIG) {
     fatal("Invalid signal %d", signal);
   }

   chains[signal].RemoveSpecialHandler(fn);
 }

 extern "C" void EnsureFrontOfChain(int signal) {
   if (signal <= 0 || signal >= _NSIG) {
     fatal("Invalid signal %d", signal);
   }

   // Read the current action without looking at the chain, it should be the expected action.
   struct sigaction current_action;
   InitializeSignalChain();
   linked_sigaction(signal, nullptr, &current_action);
   // If the sigactions don't match then we put the current action on the chain and make ourself as
   // the main action.
   if (current_action.sa_sigaction != SignalChain::Handler) {
     log("Warning: Unexpected sigaction action found %p\n", current_action.sa_sigaction);
     chains[signal].Register(signal);
   }
 }

 }   // namespace art
	/*
	* Copyright (C) 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifdef ART_TARGET_ANDROID
	#include <android/log.h>
	#else
	#include <stdarg.h>
	#include <iostream>
	#endif

	#include <dlfcn.h>
	#include <errno.h>
	#include <pthread.h>
	#include <signal.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#include <initializer_list>
	#include <mutex>
	#include <utility>

	#include "sigchain.h"

	#if defined(__APPLE__)
	#define _NSIG NSIG
	#define sighandler_t sig_t

	// Darwin has an #error when ucontext.h is included without _XOPEN_SOURCE defined.
	#define _XOPEN_SOURCE
	#endif

	#include <ucontext.h>

	// libsigchain provides an interception layer for signal handlers, to allow ART and others to give
	// their signal handlers the first stab at handling signals before passing them on to user code.
	//
	// It implements wrapper functions for signal, sigaction, and sigprocmask, and a handler that
	// forwards signals appropriately.
	//
	// In our handler, we start off with all signals blocked, fetch the original signal mask from the
	// passed in ucontext, and then adjust our signal mask appropriately for the user handler.
	//
	// It's somewhat tricky for us to properly handle some flag cases:
	// SA_NOCLDSTOP and SA_NOCLDWAIT: shouldn't matter, we don't have special handlers for SIGCHLD.
	// SA_NODEFER: unimplemented, we can manually change the signal mask appropriately.
	// ~SA_ONSTACK: always silently enable this
	// SA_RESETHAND: unimplemented, but we can probably do this?
	// ~SA_RESTART: unimplemented, maybe we can reserve an RT signal, register an empty handler that
	// doesn't have SA_RESTART, and raise the signal to avoid restarting syscalls that are
	// expected to be interrupted?

	static void log(const char* format, ...) {
	char buf[256];
	va_list ap;
	va_start(ap, format);
	vsnprintf(buf, sizeof(buf), format, ap);
	#ifdef ART_TARGET_ANDROID
	__android_log_write(ANDROID_LOG_ERROR, "libsigchain", buf);
	#else
	std::cout << buf << "\n";
	#endif
	va_end(ap);
	}

	#define fatal(...) log(__VA_ARGS__); abort()

	static int sigorset(sigset_t* dest, sigset_t* left, sigset_t* right) {
	sigemptyset(dest);
	for (size_t i = 0; i < sizeof(sigset_t) * CHAR_BIT; ++i) {
	if (sigismember(left, i) == 1 \|\| sigismember(right, i) == 1) {
	sigaddset(dest, i);
	}
	}
	return 0;
	}

	namespace art {

	static decltype(&sigaction) linked_sigaction;
	static decltype(&sigprocmask) linked_sigprocmask;

	static pthread_key_t GetHandlingSignalKey() {
	static pthread_key_t key;
	static std::once_flag once;
	std::call_once(once, []() {
	int rc = pthread_key_create(&key, nullptr);
	if (rc != 0) {
	fatal("failed to create sigchain pthread key: %s", strerror(rc));
	}
	});
	return key;
	}

	static bool GetHandlingSignal() {
	void* result = pthread_getspecific(GetHandlingSignalKey());
	return reinterpret_cast<uintptr_t>(result);
	}

	static void SetHandlingSignal(bool value) {
	pthread_setspecific(GetHandlingSignalKey(),
	reinterpret_cast<void*>(static_cast<uintptr_t>(value)));
	}

	class ScopedHandlingSignal {
	public:
	ScopedHandlingSignal() : original_value_(GetHandlingSignal()) {
	}

	~ScopedHandlingSignal() {
	SetHandlingSignal(original_value_);
	}

	private:
	bool original_value_;
	};

	class SignalChain {
	public:
	SignalChain() : claimed_(false) {
	}

	bool IsClaimed() {
	return claimed_;
	}

	void Claim(int signo) {
	if (!claimed_) {
	Register(signo);
	claimed_ = true;
	}
	}

	// Register the signal chain with the kernel if needed.
	void Register(int signo) {
	struct sigaction handler_action = {};
	handler_action.sa_sigaction = SignalChain::Handler;
	handler_action.sa_flags = SA_RESTART \| SA_SIGINFO \| SA_ONSTACK;
	sigfillset(&handler_action.sa_mask);
	linked_sigaction(signo, &handler_action, &action_);
	}

	void SetAction(const struct sigaction* action) {
	action_ = *action;
	}

	struct sigaction GetAction() {
	return action_;
	}

	void AddSpecialHandler(SpecialSignalHandlerFn fn) {
	for (SpecialSignalHandlerFn& slot : special_handlers_) {
	if (slot == nullptr) {
	slot = fn;
	return;
	}
	}

	fatal("too many special signal handlers");
	}

	void RemoveSpecialHandler(SpecialSignalHandlerFn fn) {
	// This isn't thread safe, but it's unlikely to be a real problem.
	size_t len = sizeof(special_handlers_)/sizeof(*special_handlers_);
	for (size_t i = 0; i < len; ++i) {
	if (special_handlers_[i] == fn) {
	for (size_t j = i; j < len - 1; ++j) {
	special_handlers_[j] = special_handlers_[j + 1];
	}
	special_handlers_[len - 1] = nullptr;
	return;
	}
	}

	fatal("failed to find special handler to remove");
	}


	static void Handler(int signo, siginfo_t* siginfo, void*);

	private:
	bool claimed_;
	struct sigaction action_;
	SpecialSignalHandlerFn special_handlers_[2];
	};

	static SignalChain chains[_NSIG];

	class ScopedSignalUnblocker {
	public:
	explicit ScopedSignalUnblocker(const std::initializer_list<int>& signals) {
	sigset_t new_mask;
	sigemptyset(&new_mask);
	for (int signal : signals) {
	sigaddset(&new_mask, signal);
	}
	if (sigprocmask(SIG_UNBLOCK, &new_mask, &previous_mask_) != 0) {
	fatal("failed to unblock signals: %s", strerror(errno));
	}
	}

	~ScopedSignalUnblocker() {
	if (sigprocmask(SIG_SETMASK, &previous_mask_, nullptr) != 0) {
	fatal("failed to unblock signals: %s", strerror(errno));
	}
	}

	private:
	sigset_t previous_mask_;
	};

	void SignalChain::Handler(int signo, siginfo_t* siginfo, void* ucontext_raw) {
	ScopedHandlingSignal handling_signal;

	// Try the special handlers first.
	// If one of them crashes, we'll reenter this handler and pass that crash onto the user handler.
	if (!GetHandlingSignal()) {
	ScopedSignalUnblocker unblocked { SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGSEGV }; // NOLINT
	SetHandlingSignal(true);

	for (const auto& handler : chains[signo].special_handlers_) {
	if (handler != nullptr && handler(signo, siginfo, ucontext_raw)) {
	return;
	}
	}
	}

	// Forward to the user's signal handler.
	int handler_flags = chains[signo].action_.sa_flags;
	ucontext_t* ucontext = static_cast<ucontext_t*>(ucontext_raw);
	sigset_t mask;
	sigorset(&mask, &ucontext->uc_sigmask, &chains[signo].action_.sa_mask);
	if ((handler_flags & SA_NODEFER)) {
	sigdelset(&mask, signo);
	}
	sigprocmask(SIG_SETMASK, &mask, nullptr);

	if ((handler_flags & SA_SIGINFO)) {
	chains[signo].action_.sa_sigaction(signo, siginfo, ucontext_raw);
	} else {
	auto handler = chains[signo].action_.sa_handler;
	if (handler == SIG_IGN) {
	return;
	} else if (handler == SIG_DFL) {
	fatal("exiting due to SIG_DFL handler for signal %d", signo);
	} else {
	handler(signo);
	}
	}
	}

	extern "C" int sigaction(int signal, const struct sigaction* new_action, struct sigaction* old_action) {
	// If this signal has been claimed as a signal chain, record the user's
	// action but don't pass it on to the kernel.
	// Note that we check that the signal number is in range here. An out of range signal
	// number should behave exactly as the libc sigaction.
	if (signal < 0 \|\| signal >= _NSIG) {
	errno = EINVAL;
	return -1;
	}

	if (chains[signal].IsClaimed()) {
	struct sigaction saved_action = chains[signal].GetAction();
	if (new_action != nullptr) {
	chains[signal].SetAction(new_action);
	}
	if (old_action != nullptr) {
	*old_action = saved_action;
	}
	return 0;
	}

	// Will only get here if the signal chain has not been claimed. We want
	// to pass the sigaction on to the kernel via the real sigaction in libc.
	InitializeSignalChain();
	return linked_sigaction(signal, new_action, old_action);
	}

	extern "C" sighandler_t signal(int signo, sighandler_t handler) {
	if (signo < 0 \|\| signo > _NSIG) {
	errno = EINVAL;
	return SIG_ERR;
	}

	struct sigaction sa = {};
	sigemptyset(&sa.sa_mask);
	sa.sa_handler = handler;
	sa.sa_flags = SA_RESTART \| SA_ONSTACK;
	sighandler_t oldhandler;

	// If this signal has been claimed as a signal chain, record the user's
	// action but don't pass it on to the kernel.
	if (chains[signo].IsClaimed()) {
	oldhandler = reinterpret_cast<sighandler_t>(chains[signo].GetAction().sa_handler);
	chains[signo].SetAction(&sa);
	return oldhandler;
	}

	// Will only get here if the signal chain has not been claimed. We want
	// to pass the sigaction on to the kernel via the real sigaction in libc.
	InitializeSignalChain();
	if (linked_sigaction(signo, &sa, &sa) == -1) {
	return SIG_ERR;
	}

	return reinterpret_cast<sighandler_t>(sa.sa_handler);
	}

	#if !defined(__LP64__)
	extern "C" sighandler_t bsd_signal(int signo, sighandler_t handler) {
	return signal(signo, handler);
	}
	#endif

	extern "C" int sigprocmask(int how, const sigset_t* bionic_new_set, sigset_t* bionic_old_set) {
	// When inside a signal handler, forward directly to the actual sigprocmask.
	if (GetHandlingSignal()) {
	return linked_sigprocmask(how, bionic_new_set, bionic_old_set);
	}

	const sigset_t* new_set_ptr = bionic_new_set;
	sigset_t tmpset;
	if (bionic_new_set != nullptr) {
	tmpset = *bionic_new_set;

	if (how == SIG_BLOCK) {
	// Don't allow claimed signals in the mask. If a signal chain has been claimed
	// we can't allow the user to block that signal.
	for (int i = 0 ; i < _NSIG; ++i) {
	if (chains[i].IsClaimed() && sigismember(&tmpset, i)) {
	sigdelset(&tmpset, i);
	}
	}
	}
	new_set_ptr = &tmpset;
	}

	InitializeSignalChain();
	return linked_sigprocmask(how, new_set_ptr, bionic_old_set);
	}

	extern "C" void InitializeSignalChain() {
	// Warning.
	// Don't call this from within a signal context as it makes calls to
	// dlsym. Calling into the dynamic linker will result in locks being
	// taken and if it so happens that a signal occurs while one of these
	// locks is already taken, dlsym will block trying to reenter a
	// mutex and we will never get out of it.
	static bool initialized = false;
	if (initialized) {
	// Don't initialize twice.
	return;
	}

	void* linked_sigaction_sym = dlsym(RTLD_NEXT, "sigaction");
	if (linked_sigaction_sym == nullptr) {
	linked_sigaction_sym = dlsym(RTLD_DEFAULT, "sigaction");
	if (linked_sigaction_sym == nullptr \|\|
	linked_sigaction_sym == reinterpret_cast<void*>(sigaction)) {
	fatal("Unable to find next sigaction in signal chain");
	}
	}

	void* linked_sigprocmask_sym = dlsym(RTLD_NEXT, "sigprocmask");
	if (linked_sigprocmask_sym == nullptr) {
	linked_sigprocmask_sym = dlsym(RTLD_DEFAULT, "sigprocmask");
	if (linked_sigprocmask_sym == nullptr \|\|
	linked_sigprocmask_sym == reinterpret_cast<void*>(sigprocmask)) {
	fatal("Unable to find next sigprocmask in signal chain");
	}
	}

	linked_sigaction = reinterpret_cast<decltype(linked_sigaction)>(linked_sigaction_sym);
	linked_sigprocmask = reinterpret_cast<decltype(linked_sigprocmask)>(linked_sigprocmask_sym);
	initialized = true;
	}

	extern "C" void AddSpecialSignalHandlerFn(int signal, SpecialSignalHandlerFn fn) {
	if (signal <= 0 \|\| signal >= _NSIG) {
	fatal("Invalid signal %d", signal);
	}

	// Set the managed_handler.
	chains[signal].AddSpecialHandler(fn);
	chains[signal].Claim(signal);
	}

	extern "C" void RemoveSpecialSignalHandlerFn(int signal, SpecialSignalHandlerFn fn) {
	if (signal <= 0 \|\| signal >= _NSIG) {
	fatal("Invalid signal %d", signal);
	}

	chains[signal].RemoveSpecialHandler(fn);
	}

	extern "C" void EnsureFrontOfChain(int signal) {
	if (signal <= 0 \|\| signal >= _NSIG) {
	fatal("Invalid signal %d", signal);
	}

	// Read the current action without looking at the chain, it should be the expected action.
	struct sigaction current_action;
	InitializeSignalChain();
	linked_sigaction(signal, nullptr, &current_action);
	// If the sigactions don't match then we put the current action on the chain and make ourself as
	// the main action.
	if (current_action.sa_sigaction != SignalChain::Handler) {
	log("Warning: Unexpected sigaction action found %p\n", current_action.sa_sigaction);
	chains[signal].Register(signal);
	}
	}

	} // namespace art