refactor(rfkill): poll rfkill events from Glib main loop

Open rfkill device only once per module.
Remove rfkill threads and use `Glib::signal_io` as a more efficient way
to poll the rfkill device.
Handle runtime errors from rfkill and stop polling of the device instead
of crashing waybar.

include/modules/bluetooth.hpp

@@ -1,11 +1,11 @@
 #pragma once
 
-#include <fmt/format.h>
-#include "ALabel.hpp"
-
 #include <fmt/chrono.h>
-#include "util/sleeper_thread.hpp"
+#include <fmt/format.h>
+
+#include "ALabel.hpp"
 #include "util/rfkill.hpp"
+#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 
@@ -16,11 +16,9 @@ class Bluetooth : public ALabel {
   auto update() -> void;
 
  private:
-  std::string           status_;
+  std::string         status_;
-  util::SleeperThread 	thread_;
+  util::SleeperThread thread_;
-  util::SleeperThread 	intervall_thread_;
+  util::Rfkill        rfkill_;
-
-  util::Rfkill rfkill_;
 };
 
 }  // namespace waybar::modules

include/modules/network.hpp

@@ -75,8 +75,6 @@ class Network : public ALabel {
   util::SleeperThread thread_;
   util::SleeperThread thread_timer_;
 #ifdef WANT_RFKILL
-  util::SleeperThread thread_rfkill_;
-
   util::Rfkill rfkill_;
 #endif
 };

include/util/rfkill.hpp

@@ -1,19 +1,26 @@
 #pragma once
 
+#include <glibmm/iochannel.h>
 #include <linux/rfkill.h>
+#include <sigc++/signal.h>
+#include <sigc++/trackable.h>
 
 namespace waybar::util {
 
-class Rfkill {
+class Rfkill : public sigc::trackable {
  public:
   Rfkill(enum rfkill_type rfkill_type);
-  ~Rfkill() = default;
+  ~Rfkill();
-  void waitForEvent();
   bool getState() const;
 
+  sigc::signal<void(struct rfkill_event&)> on_update;
+
  private:
   enum rfkill_type rfkill_type_;
-  int              state_ = 0;
+  bool             state_ = false;
+  int              fd_ = -1;
+
+  bool on_event(Glib::IOCondition cond);
 };
 
 }  // namespace waybar::util

src/modules/bluetooth.cpp

@@ -1,17 +1,11 @@
 #include "modules/bluetooth.hpp"
-#include "util/rfkill.hpp"
-#include <linux/rfkill.h>
-#include <time.h>
 
 waybar::modules::Bluetooth::Bluetooth(const std::string& id, const Json::Value& config)
     : ALabel(config, "bluetooth", id, "{icon}", 10),
       status_("disabled"),
       rfkill_{RFKILL_TYPE_BLUETOOTH} {
+  rfkill_.on_update.connect(sigc::hide(sigc::mem_fun(*this, &Bluetooth::update)));
   thread_ = [this] {
-    dp.emit();
-    rfkill_.waitForEvent();
-  };
-  intervall_thread_ = [this] {
     auto now = std::chrono::system_clock::now();
     auto timeout = std::chrono::floor<std::chrono::seconds>(now + interval_);
     auto diff = std::chrono::seconds(timeout.time_since_epoch().count() % interval_.count());

src/modules/network.cpp

@@ -212,18 +212,15 @@ void waybar::modules::Network::worker() {
     thread_timer_.sleep_for(interval_);
   };
 #ifdef WANT_RFKILL
-  thread_rfkill_ = [this] {
+  rfkill_.on_update.connect([this](auto &) {
-    rfkill_.waitForEvent();
+    std::lock_guard<std::mutex> lock(mutex_);
-    {
+    if (ifid_ > 0) {
-      std::lock_guard<std::mutex> lock(mutex_);
+      getInfo();
-      if (ifid_ > 0) {
+      dp.emit();
-        getInfo();
-        dp.emit();
-      }
     }
-  };
+  });
 #else
-    spdlog::warn("Waybar has been built without rfkill support.");
+  spdlog::warn("Waybar has been built without rfkill support.");
 #endif
   thread_ = [this] {
     std::array<struct epoll_event, EPOLL_MAX> events{};

src/util/rfkill.cpp

@@ -19,60 +19,63 @@
 #include "util/rfkill.hpp"
 
 #include <fcntl.h>
+#include <glibmm/main.h>
 #include <linux/rfkill.h>
-#include <poll.h>
+#include <spdlog/spdlog.h>
-#include <stdlib.h>
 #include <unistd.h>
 
 #include <cerrno>
-#include <cstring>
-#include <stdexcept>
 
-waybar::util::Rfkill::Rfkill(const enum rfkill_type rfkill_type) : rfkill_type_(rfkill_type) {}
+waybar::util::Rfkill::Rfkill(const enum rfkill_type rfkill_type) : rfkill_type_(rfkill_type) {
-
+  fd_ = open("/dev/rfkill", O_RDONLY);
-void waybar::util::Rfkill::waitForEvent() {
+  if (fd_ < 0) {
-  struct rfkill_event event;
+    spdlog::error("Can't open RFKILL control device");
-  struct pollfd       p;
-  ssize_t             len;
-  int                 fd, n;
-
-  fd = open("/dev/rfkill", O_RDONLY);
-  if (fd < 0) {
-    throw std::runtime_error("Can't open RFKILL control device");
     return;
   }
+  int rc = fcntl(fd_, F_SETFL, O_NONBLOCK);
+  if (rc < 0) {
+    spdlog::error("Can't set RFKILL control device to non-blocking: {}", errno);
+    close(fd_);
+    fd_ = -1;
+    return;
+  }
+  Glib::signal_io().connect(
+      sigc::mem_fun(*this, &Rfkill::on_event), fd_, Glib::IO_IN | Glib::IO_ERR | Glib::IO_HUP);
+}
 
-  memset(&p, 0, sizeof(p));
+waybar::util::Rfkill::~Rfkill() {
-  p.fd = fd;
+  if (fd_ >= 0) {
-  p.events = POLLIN | POLLHUP;
+    close(fd_);
+  }
+}
 
-  while (1) {
+bool waybar::util::Rfkill::on_event(Glib::IOCondition cond) {
-    n = poll(&p, 1, -1);
+  if (cond & Glib::IO_IN) {
-    if (n < 0) {
+    struct rfkill_event event;
-      throw std::runtime_error("Failed to poll RFKILL control device");
+    ssize_t             len;
-      break;
-    }
 
-    if (n == 0) continue;
+    len = read(fd_, &event, sizeof(event));
-
-    len = read(fd, &event, sizeof(event));
     if (len < 0) {
-      throw std::runtime_error("Reading of RFKILL events failed");
+      spdlog::error("Reading of RFKILL events failed: {}", errno);
-      break;
+      return false;
     }
 
     if (len < RFKILL_EVENT_SIZE_V1) {
-      throw std::runtime_error("Wrong size of RFKILL event");
+      if (errno != EAGAIN) {
-      continue;
+        spdlog::error("Wrong size of RFKILL event: {}", len);
+      }
+      return true;
     }
 
-    if (event.type == rfkill_type_ && event.op == RFKILL_OP_CHANGE) {
+    if (event.type == rfkill_type_ && (event.op == RFKILL_OP_ADD || event.op == RFKILL_OP_CHANGE)) {
       state_ = event.soft || event.hard;
-      break;
+      on_update.emit(event);
     }
+    return true;
+  } else {
+    spdlog::error("Failed to poll RFKILL control device");
+    return false;
   }
-
-  close(fd);
 }
 
 bool waybar::util::Rfkill::getState() const { return state_; }