Display and control your Android device
Introduce interruptor tool
Romain Vimonte0896142dbbb
diff --git a/app/meson.build b/app/meson.buildindex 94b4994f..8240dd16 100644--- a/app/meson.build+++ b/app/meson.build@@ -25,6 +25,7 @@ src = ['src/stream.c','src/video_buffer.c','src/util/file.c',+ 'src/util/intr.c','src/util/log.c','src/util/net.c','src/util/process.c',diff --git a/app/src/util/intr.c b/app/src/util/intr.cnew file mode 100644index 00000000..d4fce55c--- /dev/null+++ b/app/src/util/intr.c@@ -0,0 +1,83 @@+#include "intr.h"++#include "util/log.h"++#include <assert.h>++bool+sc_intr_init(struct sc_intr *intr) {+ bool ok = sc_mutex_init(&intr->mutex);+ if (!ok) {+ LOGE("Could not init intr mutex");+ return false;+ }++ intr->socket = SC_INVALID_SOCKET;+ intr->process = SC_PROCESS_NONE;++ atomic_store_explicit(&intr->interrupted, false, memory_order_relaxed);++ return true;+}++bool+sc_intr_set_socket(struct sc_intr *intr, sc_socket socket) {+ assert(intr->process == SC_PROCESS_NONE);++ sc_mutex_lock(&intr->mutex);+ bool interrupted =+ atomic_load_explicit(&intr->interrupted, memory_order_relaxed);+ if (!interrupted) {+ intr->socket = socket;+ }+ sc_mutex_unlock(&intr->mutex);++ return !interrupted;+}++bool+sc_intr_set_process(struct sc_intr *intr, sc_pid pid) {+ assert(intr->socket == SC_INVALID_SOCKET);++ sc_mutex_lock(&intr->mutex);+ bool interrupted =+ atomic_load_explicit(&intr->interrupted, memory_order_relaxed);+ if (!interrupted) {+ intr->process = pid;+ }+ sc_mutex_unlock(&intr->mutex);++ return !interrupted;+}++void+sc_intr_interrupt(struct sc_intr *intr) {+ sc_mutex_lock(&intr->mutex);++ atomic_store_explicit(&intr->interrupted, true, memory_order_relaxed);++ // No more than one component to interrupt+ assert(intr->socket == SC_INVALID_SOCKET ||+ intr->process == SC_PROCESS_NONE);++ if (intr->socket != SC_INVALID_SOCKET) {+ LOGD("Interrupting socket");+ net_interrupt(intr->socket);+ intr->socket = SC_INVALID_SOCKET;+ }+ if (intr->process != SC_PROCESS_NONE) {+ LOGD("Interrupting process");+ sc_process_terminate(intr->process);+ intr->process = SC_PROCESS_NONE;+ }++ sc_mutex_unlock(&intr->mutex);+}++void+sc_intr_destroy(struct sc_intr *intr) {+ assert(intr->socket == SC_INVALID_SOCKET);+ assert(intr->process == SC_PROCESS_NONE);++ sc_mutex_destroy(&intr->mutex);+}diff --git a/app/src/util/intr.h b/app/src/util/intr.hnew file mode 100644index 00000000..7f0fb9b7--- /dev/null+++ b/app/src/util/intr.h@@ -0,0 +1,78 @@+#ifndef SC_INTR_H+#define SC_INTR_H++#include "common.h"++#include <stdatomic.h>+#include <stdbool.h>++#include "net.h"+#include "process.h"+#include "thread.h"++/**+ * Interruptor to wake up a blocking call from another thread+ *+ * It allows to register a socket or a process before a blocking call, and+ * interrupt/close from another thread to wake up the blocking call.+ */+struct sc_intr {+ sc_mutex mutex;++ sc_socket socket;+ sc_pid process;++ // Written protected by the mutex to avoid race conditions against+ // sc_intr_set_socket() and sc_intr_set_process(), but can be read+ // (atomically) without mutex+ atomic_bool interrupted;+};++/**+ * Initialize an interruptor+ */+bool+sc_intr_init(struct sc_intr *intr);++/**+ * Set a socket as the interruptible component+ *+ * Call with SC_INVALID_SOCKET to unset.+ */+bool+sc_intr_set_socket(struct sc_intr *intr, sc_socket socket);++/**+ * Set a process as the interruptible component+ *+ * Call with SC_PROCESS_NONE to unset.+ */+bool+sc_intr_set_process(struct sc_intr *intr, sc_pid socket);++/**+ * Interrupt the current interruptible component+ *+ * Must be called from a different thread.+ */+void+sc_intr_interrupt(struct sc_intr *intr);++/**+ * Read the interrupted state+ *+ * It is exposed as a static inline function because it just loads from an+ * atomic.+ */+static inline bool+sc_intr_is_interrupted(struct sc_intr *intr) {+ return atomic_load_explicit(&intr->interrupted, memory_order_relaxed);+}++/**+ * Destroy the interruptor+ */+void+sc_intr_destroy(struct sc_intr *intr);++#endif