libcamera: event_dispatcher: Add interrupt() function

The new interrupt() function allows interrupting in-progress blocking
processEvents() calls. This is useful to stop running event loops.

Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>

1 files changed, 31 insertions, 1 deletions

diff --git a/src/libcamera/event_dispatcher_poll.cpp b/src/libcamera/event_dispatcher_poll.cpp
index 6e0609c3..a2674ab3 100644
--- a/src/libcamera/event_dispatcher_poll.cpp
+++ b/src/libcamera/event_dispatcher_poll.cpp
@@ -8,7 +8,10 @@
 #include <algorithm>
 #include <iomanip>
 #include <poll.h>
+#include <stdint.h>
 #include <string.h>
+#include <sys/eventfd.h>
+#include <unistd.h>
 
 #include <libcamera/event_notifier.h>
 #include <libcamera/timer.h>
@@ -43,10 +46,18 @@ static const char *notifierType(EventNotifier::Type type)
 
 EventDispatcherPoll::EventDispatcherPoll()
 {
+	/*
+	 * Create the event fd. Failures are fatal as we can't implement an
+	 * interruptible dispatcher without the fd.
+	 */
+	eventfd_ = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
+	if (eventfd_ < 0)
+		LOG(Event, Fatal) << "Unable to create eventfd";
 }
 
 EventDispatcherPoll::~EventDispatcherPoll()
 {
+	close(eventfd_);
 }
 
 void EventDispatcherPoll::registerEventNotifier(EventNotifier *notifier)
@@ -123,11 +134,13 @@ void EventDispatcherPoll::processEvents()
 
 	/* Create the pollfd array. */
 	std::vector<struct pollfd> pollfds;
-	pollfds.reserve(notifiers_.size());
+	pollfds.reserve(notifiers_.size() + 1);
 
 	for (auto notifier : notifiers_)
 		pollfds.push_back({ notifier.first, notifier.second.events(), 0 });
 
+	pollfds.push_back({ eventfd_, POLLIN, 0 });
+
 	/* Wait for events and process notifiers and timers. */
 	do {
 		ret = poll(&pollfds);
@@ -137,12 +150,20 @@ void EventDispatcherPoll::processEvents()
 		ret = -errno;
 		LOG(Event, Warning) << "poll() failed with " << strerror(-ret);
 	} else if (ret > 0) {
+		processInterrupt(pollfds.back());
+		pollfds.pop_back();
 		processNotifiers(pollfds);
 	}
 
 	processTimers();
 }
 
+void EventDispatcherPoll::interrupt()
+{
+	uint64_t value = 1;
+	write(eventfd_, &value, sizeof(value));
+}
+
 short EventDispatcherPoll::EventNotifierSetPoll::events() const
 {
 	short events = 0;
@@ -186,6 +207,15 @@ int EventDispatcherPoll::poll(std::vector<struct pollfd> *pollfds)
 		     nextTimer ? &timeout : nullptr, nullptr);
 }
 
+void EventDispatcherPoll::processInterrupt(const struct pollfd &pfd)
+{
+	if (!pfd.revents & POLLIN)
+		return;
+
+	uint64_t value;
+	read(eventfd_, &value, sizeof(value));
+}
+
 void EventDispatcherPoll::processNotifiers(const std::vector<struct pollfd> &pollfds)
 {
 	static const struct {