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

system/gd/os/alarm.h

+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_;

system/gd/os/handler.h

+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_;

system/gd/os/linux_generic/alarm.cc

+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_));

system/gd/os/linux_generic/handler.cc

+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;

system/gd/os/linux_generic/queue.tpp

+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;

}