Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 86d57ec7 authored by Myles Watson's avatar Myles Watson
Browse files

OS: Construct Handler using Reactor

Store a Reactor instead of a Thread in Handler.  Allow construction from either.
Test: bluetooth_test_gd --gtest_filter=QueueTestSingleThread.no_unregister_enqueue_death_test

Change-Id: I610e6f4ffb48120d1fa47b4ff59b59375c7a11d8
parent 51530fc0
Loading
Loading
Loading
Loading
+4 −1
Original line number Diff line number Diff line
@@ -34,6 +34,9 @@ class Alarm {
  // Create and register a single-shot alarm on given thread
  explicit Alarm(Thread* thread);

  // Create and register a single-shot alarm with a given reactor
  explicit Alarm(Reactor* reactor);

  // Unregister this alarm from the thread and release resource
  ~Alarm();

@@ -47,7 +50,7 @@ class Alarm {

 private:
  Closure task_;
  Thread* thread_;
  Reactor* reactor_;
  int fd_ = 0;
  Reactor::Reactable* token_;
  mutable std::mutex mutex_;
+4 −1
Original line number Diff line number Diff line
@@ -35,6 +35,9 @@ class Handler {
  // Create and register a handler on given thread
  explicit Handler(Thread* thread);

  // Create and register a handler with a given reactor
  explicit Handler(Reactor* reactor);

  // Unregister this handler from the thread and release resource. Unhandled events will be discarded and not executed.
  ~Handler();

@@ -51,7 +54,7 @@ class Handler {

 private:
  std::queue<Closure> tasks_;
  Thread* thread_;
  Reactor* reactor_;
  int fd_;
  Reactor::Reactable* reactable_;
  mutable std::mutex mutex_;
+5 −5
Original line number Diff line number Diff line
@@ -32,16 +32,16 @@
namespace bluetooth {
namespace os {

Alarm::Alarm(Thread* thread)
  : thread_(thread),
    fd_(timerfd_create(ALARM_CLOCK, 0)) {
Alarm::Alarm(Reactor* reactor) : reactor_(reactor), fd_(timerfd_create(ALARM_CLOCK, 0)) {
  ASSERT_LOG(fd_ != -1, "cannot create timerfd: %s", strerror(errno));

  token_ = thread_->GetReactor()->Register(fd_, [this] { on_fire(); }, nullptr);
  token_ = reactor_->Register(fd_, [this] { on_fire(); }, nullptr);
}

Alarm::Alarm(Thread* thread) : Alarm(thread->GetReactor()) {}

Alarm::~Alarm() {
  thread_->GetReactor()->Unregister(token_);
  reactor_->Unregister(token_);

  int close_status;
  RUN_NO_INTR(close_status = close(fd_));
+5 −5
Original line number Diff line number Diff line
@@ -31,16 +31,16 @@
namespace bluetooth {
namespace os {

Handler::Handler(Thread* thread)
  : thread_(thread),
    fd_(eventfd(0, EFD_SEMAPHORE | EFD_NONBLOCK)) {
Handler::Handler(Reactor* reactor) : reactor_(reactor), fd_(eventfd(0, EFD_SEMAPHORE | EFD_NONBLOCK)) {
  ASSERT(fd_ != -1);

  reactable_ = thread_->GetReactor()->Register(fd_, [this] { this->handle_next_event(); }, nullptr);
  reactable_ = reactor_->Register(fd_, [this] { this->handle_next_event(); }, nullptr);
}

Handler::Handler(Thread* thread) : Handler(thread->GetReactor()) {}

Handler::~Handler() {
  thread_->GetReactor()->Unregister(reactable_);
  reactor_->Unregister(reactable_);
  reactable_ = nullptr;

  int close_status;
+4 −4
Original line number Diff line number Diff line
@@ -30,7 +30,7 @@ void Queue<T>::RegisterEnqueue(Handler* handler, EnqueueCallback callback) {
  ASSERT(enqueue_.handler_ == nullptr);
  ASSERT(enqueue_.reactable_ == nullptr);
  enqueue_.handler_ = handler;
  enqueue_.reactable_ = enqueue_.handler_->thread_->GetReactor()->Register(
  enqueue_.reactable_ = enqueue_.handler_->reactor_->Register(
      enqueue_.reactive_semaphore_.GetFd(), [this, callback] { EnqueueCallbackInternal(callback); }, nullptr);
}

@@ -38,7 +38,7 @@ template <typename T>
void Queue<T>::UnregisterEnqueue() {
  std::lock_guard<std::mutex> lock(mutex_);
  ASSERT(enqueue_.reactable_ != nullptr);
  enqueue_.handler_->thread_->GetReactor()->Unregister(enqueue_.reactable_);
  enqueue_.handler_->reactor_->Unregister(enqueue_.reactable_);
  enqueue_.reactable_ = nullptr;
  enqueue_.handler_ = nullptr;
}
@@ -49,7 +49,7 @@ void Queue<T>::RegisterDequeue(Handler* handler, DequeueCallback callback) {
  ASSERT(dequeue_.handler_ == nullptr);
  ASSERT(dequeue_.reactable_ == nullptr);
  dequeue_.handler_ = handler;
  dequeue_.reactable_ = dequeue_.handler_->thread_->GetReactor()->Register(dequeue_.reactive_semaphore_.GetFd(),
  dequeue_.reactable_ = dequeue_.handler_->reactor_->Register(dequeue_.reactive_semaphore_.GetFd(),
                                                                           [callback] { callback(); }, nullptr);
}

@@ -57,7 +57,7 @@ template <typename T>
void Queue<T>::UnregisterDequeue() {
  std::lock_guard<std::mutex> lock(mutex_);
  ASSERT(dequeue_.reactable_ != nullptr);
  dequeue_.handler_->thread_->GetReactor()->Unregister(dequeue_.reactable_);
  dequeue_.handler_->reactor_->Unregister(dequeue_.reactable_);
  dequeue_.reactable_ = nullptr;
  dequeue_.handler_ = nullptr;
}
Loading