folly::AsyncSignalHandler Class Reference

#include <AsyncSignalHandler.h>

Inheritance diagram for folly::AsyncSignalHandler:

Public Member Functions
	AsyncSignalHandler (EventBase *eventBase)
virtual	~AsyncSignalHandler ()
void	attachEventBase (EventBase *eventBase)
void	detachEventBase ()
EventBase *	getEventBase () const
void	registerSignalHandler (int signum)
void	unregisterSignalHandler (int signum)
virtual void	signalReceived (int signum) noexcept=0

Private Types
typedef std::map< int, struct event >	SignalEventMap

Private Member Functions
	AsyncSignalHandler (AsyncSignalHandler const &)
AsyncSignalHandler &	operator= (AsyncSignalHandler const &)

Static Private Member Functions
static void	libeventCallback (libevent_fd_t signum, short events, void *arg)

Private Attributes
EventBase *	eventBase_ {nullptr}
SignalEventMap	signalEvents_

Detailed Description

A handler to receive notification about POSIX signals.

AsyncSignalHandler allows code to process signals from within a EventBase loop.

Standard signal handlers interrupt execution of the main thread, and are run while the main thread is paused. As a result, great care must be taken to avoid race conditions if the signal handler has to access or modify any data used by the main thread.

AsyncSignalHandler solves this problem by running the AsyncSignalHandler callback in normal thread of execution, as a EventBase callback.

AsyncSignalHandler may only be used in a single thread. It will only process signals received by the thread where the AsyncSignalHandler is registered. It is the user's responsibility to ensure that signals are delivered to the desired thread in multi-threaded programs.

Definition at line 43 of file AsyncSignalHandler.h.

Member Typedef Documentation

typedef std::map<int, struct event> folly::AsyncSignalHandler::SignalEventMap

private

Definition at line 105 of file AsyncSignalHandler.h.

Constructor & Destructor Documentation

folly::AsyncSignalHandler::AsyncSignalHandler ( EventBase *  eventBase )

explicit

Create a new AsyncSignalHandler.

Definition at line 28 of file AsyncSignalHandler.cpp.

    : eventBase_(eventBase) {}

folly::AsyncSignalHandler::~AsyncSignalHandler ( )

virtual

Definition at line 31 of file AsyncSignalHandler.cpp.

References signalEvents_.

                                        {
  // Unregister any outstanding events
  for (SignalEventMap::iterator it = signalEvents_.begin();
       it != signalEvents_.end();
       ++it) {
    event_del(&it->second);
  }
}

folly::AsyncSignalHandler::AsyncSignalHandler ( AsyncSignalHandler const &  )

private

Member Function Documentation

void folly::AsyncSignalHandler::attachEventBase

(

EventBase *

eventBase

)

Attach this AsyncSignalHandler to an EventBase.

This should only be called if the AsyncSignalHandler is not currently registered for any signals and is not currently attached to an existing EventBase.

Definition at line 40 of file AsyncSignalHandler.cpp.

References eventBase_, and signalEvents_.

                                                             {
  assert(eventBase_ == nullptr);
  assert(signalEvents_.empty());
  eventBase_ = eventBase;
}

void folly::AsyncSignalHandler::detachEventBase

(

)

Detach this AsyncSignalHandler from its EventBase.

This should only be called if the AsyncSignalHandler is not currently registered for any signals.

Definition at line 46 of file AsyncSignalHandler.cpp.

References eventBase_, and signalEvents_.

                                         {
  assert(eventBase_ != nullptr);
  assert(signalEvents_.empty());
  eventBase_ = nullptr;
}

EventBase* folly::AsyncSignalHandler::getEventBase ( ) const

inline

Get the EventBase used by this AsyncSignalHandler.

Definition at line 71 of file AsyncSignalHandler.h.

References eventBase_, folly::pushmi::__adl::noexcept(), registerSignalHandler(), signalReceived(), and unregisterSignalHandler().

                                  {
    return eventBase_;
  }

void folly::AsyncSignalHandler::libeventCallback ( libevent_fd_t  signum, short  events, void *  arg  )

staticprivate

Definition at line 92 of file AsyncSignalHandler.cpp.

References handler(), and signalReceived().

Referenced by registerSignalHandler().

               {
  AsyncSignalHandler* handler = static_cast<AsyncSignalHandler*>(arg);
  handler->signalReceived(int(signum));
}

AsyncSignalHandler& folly::AsyncSignalHandler::operator= ( AsyncSignalHandler const &  )

private

void folly::AsyncSignalHandler::registerSignalHandler

(

int

signum

)

Register to receive callbacks about the specified signal.

Once the handler has been registered for a particular signal, signalReceived() will be called each time this thread receives this signal.

Throws if an error occurs or if this handler is already registered for this signal.

Definition at line 52 of file AsyncSignalHandler.cpp.

References eventBase_, folly::EventBase::getLibeventBase(), libeventCallback(), and signalEvents_.

Referenced by getEventBase(), and proxygen::SignalHandler::install().

                                                         {
  pair<SignalEventMap::iterator, bool> ret =
      signalEvents_.insert(make_pair(signum, event()));
  if (!ret.second) {
    // This signal has already been registered
    throw std::runtime_error(
        folly::to<string>("handler already registered for signal ", signum));
  }

  struct event* ev = &(ret.first->second);
  try {
    signal_set(ev, signum, libeventCallback, this);
    if (event_base_set(eventBase_->getLibeventBase(), ev) != 0) {
      throw std::runtime_error(folly::to<string>(
          "error initializing event handler for signal ", signum));
    }

    if (event_add(ev, nullptr) != 0) {
      throw std::runtime_error(
          folly::to<string>("error adding event handler for signal ", signum));
    }
  } catch (...) {
    signalEvents_.erase(ret.first);
    throw;
  }
}

virtual void folly::AsyncSignalHandler::signalReceived ( int  signum )

pure virtualnoexcept

signalReceived() will called to indicate that the specified signal has been received.

signalReceived() will always be invoked from the EventBase loop (i.e., after the main POSIX signal handler has returned control to the EventBase thread).

Implemented in proxygen::SignalHandler.

Referenced by getEventBase(), and libeventCallback().

void folly::AsyncSignalHandler::unregisterSignalHandler

(

int

signum

)

Unregister for callbacks about the specified signal.

Throws if an error occurs, or if this signal was not registered.

Definition at line 79 of file AsyncSignalHandler.cpp.

References signalEvents_.

Referenced by getEventBase().

                                                           {
  SignalEventMap::iterator it = signalEvents_.find(signum);
  if (it == signalEvents_.end()) {
    throw std::runtime_error(folly::to<string>(
        "unable to unregister handler for signal ",
        signum,
        ": signal not registered"));
  }

  event_del(&it->second);
  signalEvents_.erase(it);
}

Member Data Documentation

EventBase* folly::AsyncSignalHandler::eventBase_ {nullptr}

private

Definition at line 113 of file AsyncSignalHandler.h.

Referenced by attachEventBase(), detachEventBase(), getEventBase(), and registerSignalHandler().

SignalEventMap folly::AsyncSignalHandler::signalEvents_

private

Definition at line 114 of file AsyncSignalHandler.h.

Referenced by attachEventBase(), detachEventBase(), registerSignalHandler(), unregisterSignalHandler(), and ~AsyncSignalHandler().

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/io/async/AsyncSignalHandler.h
• proxygen/folly/folly/io/async/AsyncSignalHandler.cpp