Naming and documentation tweaks based on review feedback

sporksmith · sporksmith · commit 0ad9a7837bc2 · 2021-08-20T12:26:31.000-05:00
diff --git a/src/main/host/syscall/protected.c b/src/main/host/syscall/protected.c
@@ -19,21 +19,21 @@
 #include "main/host/syscall_condition.h"
 #include "main/host/thread.h"
 
-static const Timer* _syscallhandler_timeout(const SysCallHandler* sys) {
+static const Timer* _syscallhandler_getTimeout(const SysCallHandler* sys) {
     MAGIC_ASSERT(sys);
 
     SysCallCondition* cond = thread_getSysCallCondition(sys->thread);
     if (!cond) {
         return NULL;
     }
 
-    return syscallcondition_timeout(cond);
+    return syscallcondition_getTimeout(cond);
 }
 
 bool _syscallhandler_isListenTimeoutPending(SysCallHandler* sys) {
     MAGIC_ASSERT(sys);
 
-    const Timer* timeout = _syscallhandler_timeout(sys);
+    const Timer* timeout = _syscallhandler_getTimeout(sys);
     if (!timeout) {
         return false;
     }
@@ -49,7 +49,7 @@ bool _syscallhandler_isListenTimeoutPending(SysCallHandler* sys) {
 bool _syscallhandler_didListenTimeoutExpire(const SysCallHandler* sys) {
     MAGIC_ASSERT(sys);
 
-    const Timer* timeout = _syscallhandler_timeout(sys);
+    const Timer* timeout = _syscallhandler_getTimeout(sys);
     if (!timeout) {
         return false;
     }
diff --git a/src/main/host/syscall_condition.c b/src/main/host/syscall_condition.c
@@ -33,8 +33,10 @@ struct _SysCallCondition {
     Process* proc;
     // The thread waiting for the signal
     Thread* thread;
-    // If a task to deliver a signal has been scheduled
-    bool signalScheduled;
+    // Whether the condition has *ever* been triggered. Used to prevent multiple
+    // signals from a single condition, even if its triggered multiple times or
+    // ways.
+    bool signalTriggered;
     // Memory tracking
     gint referenceCount;
     MAGIC_DECLARE;
@@ -328,7 +330,7 @@ static void _syscallcondition_scheduleSignalTask(SysCallCondition* cond,
                                                  bool wasTimeout) {
     MAGIC_ASSERT(cond);
 
-    if (cond->signalScheduled) {
+    if (cond->signalTriggered) {
         // Deliver one signal even if condition is triggered multiple times or
         // ways.
         return;
@@ -347,7 +349,7 @@ static void _syscallcondition_scheduleSignalTask(SysCallCondition* cond,
     syscallcondition_ref(cond);
     task_unref(signalTask);
 
-    cond->signalScheduled = true;
+    cond->signalTriggered = true;
 }
 
 static void _syscallcondition_notifyStatusChanged(void* obj, void* arg) {
@@ -460,4 +462,4 @@ void syscallcondition_cancel(SysCallCondition* cond) {
     _syscallcondition_cleanupProc(cond);
 }
 
-Timer* syscallcondition_timeout(SysCallCondition* cond) { return cond->timeout; }
+Timer* syscallcondition_getTimeout(SysCallCondition* cond) { return cond->timeout; }
diff --git a/src/main/host/syscall_condition.h b/src/main/host/syscall_condition.h
@@ -47,7 +47,8 @@ struct _Trigger {
  * The condition starts with a reference count of 1. */
 SysCallCondition* syscallcondition_new(Trigger trigger);
 
-/* Add a timeout to the condition. `t` is absolute emulated time, as returned by
+/* Add a timeout to the condition. At time `t`, the conditition will be triggered
+ * if it hasn't already. `t` is absolute emulated time, as returned by
  * `worker_getEmulatedTime`. */
 void syscallcondition_setTimeout(SysCallCondition* cond, Host* host, EmulatedTime t);
 
@@ -70,6 +71,6 @@ void syscallcondition_waitNonblock(SysCallCondition* cond, Process* proc,
 void syscallcondition_cancel(SysCallCondition* cond);
 
 /* Get the timer for the condition, or NULL if there isn't one. */
-Timer* syscallcondition_timeout(SysCallCondition* cond);
+Timer* syscallcondition_getTimeout(SysCallCondition* cond);
 
 #endif /* SRC_MAIN_HOST_SYSCALL_CONDITION_H_ */
