Display and control your Android device
Introduce process observer
Romain Vimont03de9224fc45
diff --git a/app/src/server.c b/app/src/server.cindex 326d0e79..f108c7cc 100644--- a/app/src/server.c+++ b/app/src/server.c@@ -329,19 +329,6 @@ server_init(struct server *server) {server->serial = NULL;server->process = SC_PROCESS_NONE;- bool ok = sc_mutex_init(&server->mutex);- if (!ok) {- return false;- }-- ok = sc_cond_init(&server->process_terminated_cond);- if (!ok) {- sc_mutex_destroy(&server->mutex);- return false;- }-- server->process_terminated = false;-server->server_socket = SC_INVALID_SOCKET;server->video_socket = SC_INVALID_SOCKET;server->control_socket = SC_INVALID_SOCKET;@@ -354,25 +341,20 @@ server_init(struct server *server) {return true;}-static int-run_wait_server(void *data) {- struct server *server = data;- sc_process_wait(server->process, false); // ignore exit code-- sc_mutex_lock(&server->mutex);- server->process_terminated = true;- sc_cond_signal(&server->process_terminated_cond);- sc_mutex_unlock(&server->mutex);+static void+server_on_terminated(void *userdata) {+ struct server *server = userdata;- // no need for synchronization, server_socket is initialized before this- // thread was created+ // No need for synchronization, server_socket is initialized before the+ // observer thread is created.if (server->server_socket != SC_INVALID_SOCKET) {- // Unblock any accept()+ // If the server process dies before connecting to the server socket,+ // then the client will be stuck forever on accept(). To avoid the+ // problem, wake up the accept() call when the server dies.net_interrupt(server->server_socket);}LOGD("Server terminated");- return 0;}bool@@ -400,14 +382,11 @@ server_start(struct server *server, const struct server_params *params) {goto error;}- // If the server process dies before connecting to the server socket, then- // the client will be stuck forever on accept(). To avoid the problem, we- // must be able to wake up the accept() call when the server dies. To keep- // things simple and multiplatform, just spawn a new thread waiting for the- // server process and calling shutdown()/close() on the server socket if- // necessary to wake up any accept() blocking call.- bool ok = sc_thread_create(&server->wait_server_thread, run_wait_server,- "wait-server", server);+ static const struct sc_process_listener listener = {+ .on_terminated = server_on_terminated,+ };+ bool ok = sc_process_observer_init(&server->observer, server->process,+ &listener, server);if (!ok) {sc_process_terminate(server->process);sc_process_wait(server->process, true); // ignore exit code@@ -516,27 +495,25 @@ server_stop(struct server *server) {}// Give some delay for the server to terminate properly- sc_mutex_lock(&server->mutex);- bool signaled = false;- if (!server->process_terminated) {#define WATCHDOG_DELAY SC_TICK_FROM_SEC(1)- signaled = sc_cond_timedwait(&server->process_terminated_cond,- &server->mutex,- sc_tick_now() + WATCHDOG_DELAY);- }- sc_mutex_unlock(&server->mutex);+ sc_tick deadline = sc_tick_now() + WATCHDOG_DELAY;+ bool terminated =+ sc_process_observer_timedwait(&server->observer, deadline);// After this delay, kill the server if it's not dead already.// On some devices, closing the sockets is not sufficient to wake up the// blocking calls while the device is asleep.- if (!signaled) {- // The process is terminated, but not reaped (closed) yet, so its PID- // is still valid.+ if (!terminated) {+ // The process may have terminated since the check, but it is not+ // reaped (closed) yet, so its PID is still valid, and it is ok to call+ // sc_process_terminate() even in that case.LOGW("Killing the server...");sc_process_terminate(server->process);}- sc_thread_join(&server->wait_server_thread, NULL);+ sc_process_observer_join(&server->observer);+ sc_process_observer_destroy(&server->observer);+sc_process_close(server->process);}@@ -558,6 +535,4 @@ server_destroy(struct server *server) {}}free(server->serial);- sc_cond_destroy(&server->process_terminated_cond);- sc_mutex_destroy(&server->mutex);}diff --git a/app/src/server.h b/app/src/server.hindex 18721cf7..c06b3562 100644--- a/app/src/server.h+++ b/app/src/server.h@@ -22,12 +22,10 @@ struct server_info {struct server {char *serial;- sc_pid process;- sc_thread wait_server_thread;- sc_mutex mutex;- sc_cond process_terminated_cond;- bool process_terminated;+ sc_pid process;+ // alive only between start() and stop()+ struct sc_process_observer observer;sc_socket server_socket; // only used if !tunnel_forwardsc_socket video_socket;diff --git a/app/src/util/process.c b/app/src/util/process.cindex 6743438e..28f51edd 100644--- a/app/src/util/process.c+++ b/app/src/util/process.c@@ -1,5 +1,6 @@#include "process.h"+#include <assert.h>#include <libgen.h>#include "log.h"@@ -41,3 +42,80 @@ sc_pipe_read_all(sc_pipe pipe, char *data, size_t len) {}return copied;}++static int+run_observer(void *data) {+ struct sc_process_observer *observer = data;+ sc_process_wait(observer->pid, false); // ignore exit code++ sc_mutex_lock(&observer->mutex);+ observer->terminated = true;+ sc_cond_signal(&observer->cond_terminated);+ sc_mutex_unlock(&observer->mutex);++ if (observer->listener) {+ observer->listener->on_terminated(observer->listener_userdata);+ }++ return 0;+}++bool+sc_process_observer_init(struct sc_process_observer *observer, sc_pid pid,+ const struct sc_process_listener *listener,+ void *listener_userdata) {+ // Either no listener, or on_terminated() is defined+ assert(!listener || listener->on_terminated);++ bool ok = sc_mutex_init(&observer->mutex);+ if (!ok) {+ return false;+ }++ ok = sc_cond_init(&observer->cond_terminated);+ if (!ok) {+ sc_mutex_destroy(&observer->mutex);+ return false;+ }++ observer->pid = pid;+ observer->listener = listener;+ observer->listener_userdata = listener_userdata;+ observer->terminated = false;++ ok = sc_thread_create(&observer->thread, run_observer, "process_observer",+ observer);+ if (!ok) {+ sc_cond_destroy(&observer->cond_terminated);+ sc_mutex_destroy(&observer->mutex);+ return false;+ }++ return true;+}++bool+sc_process_observer_timedwait(struct sc_process_observer *observer,+ sc_tick deadline) {+ sc_mutex_lock(&observer->mutex);+ bool timed_out = false;+ while (!observer->terminated && !timed_out) {+ timed_out = !sc_cond_timedwait(&observer->cond_terminated,+ &observer->mutex, deadline);+ }+ bool terminated = observer->terminated;+ sc_mutex_unlock(&observer->mutex);++ return terminated;+}++void+sc_process_observer_join(struct sc_process_observer *observer) {+ sc_thread_join(&observer->thread, NULL);+}++void+sc_process_observer_destroy(struct sc_process_observer *observer) {+ sc_cond_destroy(&observer->cond_terminated);+ sc_mutex_destroy(&observer->mutex);+}diff --git a/app/src/util/process.h b/app/src/util/process.hindex b4980b43..7964be5c 100644--- a/app/src/util/process.h+++ b/app/src/util/process.h@@ -4,6 +4,7 @@#include "common.h"#include <stdbool.h>+#include "util/thread.h"#ifdef _WIN32@@ -32,6 +33,34 @@#endif+struct sc_process_listener {+ void (*on_terminated)(void *userdata);+};++/**+ * Tool to observe process termination+ *+ * To keep things simple and multiplatform, it runs a separate thread to wait+ * for process termination (without closing the process to avoid race+ * conditions).+ *+ * It allows a caller to block until the process is terminated (with a+ * timeout), and to be notified asynchronously from the observer thread.+ *+ * The process is not owned by the observer (the observer will never close it).+ */+struct sc_process_observer {+ sc_pid pid;++ sc_mutex mutex;+ sc_cond cond_terminated;+ bool terminated;++ sc_thread thread;+ const struct sc_process_listener *listener;+ void *listener_userdata;+};+enum sc_process_result {SC_PROCESS_SUCCESS,SC_PROCESS_ERROR_GENERIC,@@ -106,4 +135,42 @@ sc_pipe_read_all(sc_pipe pipe, char *data, size_t len);voidsc_pipe_close(sc_pipe pipe);+/**+ * Start observing process+ *+ * The listener is optional. If set, its callback will be called from the+ * observer thread once the process is terminated.+ */+bool+sc_process_observer_init(struct sc_process_observer *observer, sc_pid pid,+ const struct sc_process_listener *listener,+ void *listener_userdata);++/**+ * Wait for process termination until a deadline+ *+ * Return true if the process is already terminated. Return false if the+ * process terminatation has not been detected yet (however, it may have+ * terminated in the meantime).+ *+ * To wait without timeout/deadline, just use sc_process_wait() instead.+ */+bool+sc_process_observer_timedwait(struct sc_process_observer *observer,+ sc_tick deadline);++/**+ * Join the observer thread+ */+void+sc_process_observer_join(struct sc_process_observer *observer);++/**+ * Destroy the observer+ *+ * This does not close the associated process.+ */+void+sc_process_observer_destroy(struct sc_process_observer *observer);+#endif