wait: Rename UsermodeEvent and UsermodeTimer

nx/include/switch/kernel/uevent.h

@@ -2,9 +2,9 @@
 #pragma once
 #include "../kernel/wait.h"
 
-typedef struct UsermodeEvent UsermodeEvent;
+typedef struct UEvent UEvent;
 
-struct UsermodeEvent
+struct UEvent
 {
     Waitable waitable;
     bool signal;
@@ -13,19 +13,19 @@ struct UsermodeEvent
 
 /**
  * @brief Creates a usermode event.
- * @param[out] e UsermodeEvent object.
+ * @param[out] e UEvent object.
  * @param[in] bool auto_clear Whether to automatically clear the event.
  * @note It is safe to wait on this event with several threads simultaneously.
  * @note If more than one thread is listening on it, at least one thread will get the signal. No other guarantees.
  */
-void ueventCreate(UsermodeEvent* e, bool auto_clear);
+void ueventCreate(UEvent* e, bool auto_clear);
 /**
  * @brief Clears the event signal.
- * @param[in] e UsermodeEvent object.
+ * @param[in] e UEvent object.
  */
-void ueventClear(UsermodeEvent* e);
+void ueventClear(UEvent* e);
 /**
  * @brief Signals the event.
- * @param[in] e UsermodeEvent object.
+ * @param[in] e UEvent object.
  */
-void ueventSignal(UsermodeEvent* e);
+void ueventSignal(UEvent* e);

nx/include/switch/kernel/utimer.h

@@ -2,14 +2,14 @@
 #pragma once
 #include "../kernel/wait.h"
 
-typedef struct UsermodeTimer UsermodeTimer;
+typedef struct UTimer UTimer;
 
 typedef enum {
     TimerType_OneShot,
     TimerType_Repeating
 } TimerType;
 
-struct UsermodeTimer
+struct UTimer
 {
     Waitable waitable;
     TimerType type;
@@ -19,21 +19,21 @@ struct UsermodeTimer
 
 /**
  * @brief Creates a usermode timer.
- * @param[out] t UsermodeTimer object.
+ * @param[out] t UTimer object.
  * @param[in] interval Interval (in nanoseconds).
  * @param[in] type Timer type (repeating or one-shot)
  * @note It is safe to wait on this timer with several threads simultaneously.
  * @note If more than one thread is listening on it, at least one thread will get the signal. No other guarantees.
  * @note For a repeating timer: If the timer triggers twice before you wait on it, you will only get one signal.
  */
-void utimerCreate(UsermodeTimer* t, u64 interval, TimerType type);
+void utimerCreate(UTimer* t, u64 interval, TimerType type);
 /**
  * @brief Starts the timer.
- * @param[in] t UsermodeTimer object.
+ * @param[in] t UTimer object.
  */
-void utimerStart(UsermodeTimer* t);
+void utimerStart(UTimer* t);
 /**
  * @brief Stops the timer.
- * @param[in] t UsermodeTimer object.
+ * @param[in] t UTimer object.
  */
-void utimerStop(UsermodeTimer* t);
+void utimerStop(UTimer* t);

nx/include/switch/kernel/wait.h

@@ -5,8 +5,8 @@
 #include "../kernel/thread.h"
 
 // Implementation details.
-typedef struct UsermodeEvent UsermodeEvent;
-typedef struct UsermodeTimer UsermodeTimer;
+typedef struct UEvent UEvent;
+typedef struct UTimer UTimer;
 
 typedef enum {
     WaiterNodeType_Event,
@@ -28,8 +28,8 @@ typedef struct {
     Handle thread;
     union {
         Waitable* parent;
-        UsermodeEvent* parent_event;
-        UsermodeTimer* parent_timer;
+        UEvent* parent_event;
+        UTimer* parent_timer;
     };
     size_t idx;
     size_t* idx_out;
@@ -44,8 +44,8 @@ struct Waitable
 // User-facing API starts here.
 typedef enum {
     WaiterType_Handle,
-    WaiterType_UsermodeTimer,
-    WaiterType_UsermodeEvent,
+    WaiterType_UTimer,
+    WaiterType_UEvent,
 } WaiterType;
 
 typedef struct {
@@ -53,8 +53,8 @@ typedef struct {
 
     union {
         Handle handle;
-        UsermodeTimer* timer;
-        UsermodeEvent* event;
+        UTimer* timer;
+        UEvent* event;
     };
 } Waiter;
 
@@ -68,19 +68,19 @@ static inline Waiter waiterForHandle(Handle h)
 }
 
 /// Creates a waiter for a usermode timer.
-static inline Waiter waiterForUtimer(UsermodeTimer* t)
+static inline Waiter waiterForUTimer(UTimer* t)
 {
     Waiter wait_obj;
-    wait_obj.type = WaiterType_UsermodeTimer;
+    wait_obj.type = WaiterType_UTimer;
     wait_obj.timer = t;
     return wait_obj;
 }
 
 /// Creates a waiter for a usermode event.
-static inline Waiter waiterForUevent(UsermodeEvent* e)
+static inline Waiter waiterForUEvent(UEvent* e)
 {
     Waiter wait_obj;
-    wait_obj.type = WaiterType_UsermodeEvent;
+    wait_obj.type = WaiterType_UEvent;
     wait_obj.event = e;
     return wait_obj;
 }

nx/source/kernel/uevent.c

@@ -5,7 +5,7 @@
 #include "wait.h"
 #include "uevent.h"
 
-void ueventCreate(UsermodeEvent* e, bool auto_clear)
+void ueventCreate(UEvent* e, bool auto_clear)
 {
     _waitableInitialize(&e->waitable);
 
@@ -13,14 +13,14 @@ void ueventCreate(UsermodeEvent* e, bool auto_clear)
     e->auto_clear = auto_clear;
 }
 
-void ueventClear(UsermodeEvent* e)
+void ueventClear(UEvent* e)
 {
     mutexLock(&e->waitable.mutex);
     e->signal = false;
     mutexUnlock(&e->waitable.mutex);
 }
 
-void ueventSignal(UsermodeEvent* e)
+void ueventSignal(UEvent* e)
 {
     mutexLock(&e->waitable.mutex);
     e->signal = true;
@@ -28,7 +28,7 @@ void ueventSignal(UsermodeEvent* e)
     mutexUnlock(&e->waitable.mutex);
 }
 
-void _ueventTryAutoClear(UsermodeEvent* e)
+void _ueventTryAutoClear(UEvent* e)
 {
     mutexLock(&e->waitable.mutex);
     if (e->auto_clear) {
@@ -37,7 +37,7 @@ void _ueventTryAutoClear(UsermodeEvent* e)
     mutexUnlock(&e->waitable.mutex);
 }
 
-bool _ueventAddListener(UsermodeEvent* e, WaiterNode* w, size_t idx, size_t* idx_out, Handle thread)
+bool _ueventAddListener(UEvent* e, WaiterNode* w, size_t idx, size_t* idx_out, Handle thread)
 {
     _waiterNodeCreate(w, WaiterNodeType_Event, &e->waitable, thread, idx, idx_out);
 

nx/source/kernel/uevent.h

@@ -2,5 +2,5 @@
 #pragma once
 #include "kernel/uevent.h"
 
-void _ueventTryAutoClear(UsermodeEvent* e);
-bool _ueventAddListener(UsermodeEvent* e, WaiterNode* w, size_t idx, size_t* idx_out, Handle thread);
+void _ueventTryAutoClear(UEvent* e);
+bool _ueventAddListener(UEvent* e, WaiterNode* w, size_t idx, size_t* idx_out, Handle thread);

nx/source/kernel/utimer.c

@@ -7,7 +7,7 @@
 
 #define STOPPED 0
 
-void utimerCreate(UsermodeTimer* t, u64 interval, TimerType type)
+void utimerCreate(UTimer* t, u64 interval, TimerType type)
 {
     _waitableInitialize(&t->waitable);
 
@@ -16,7 +16,7 @@ void utimerCreate(UsermodeTimer* t, u64 interval, TimerType type)
     t->type = type;
 }
 
-void utimerStart(UsermodeTimer* t)
+void utimerStart(UTimer* t)
 {
     mutexLock(&t->waitable.mutex);
 
@@ -30,7 +30,7 @@ void utimerStart(UsermodeTimer* t)
     mutexUnlock(&t->waitable.mutex);
 }
 
-void utimerStop(UsermodeTimer* t)
+void utimerStop(UTimer* t)
 {
     mutexLock(&t->waitable.mutex);
 
@@ -43,7 +43,7 @@ void utimerStop(UsermodeTimer* t)
     mutexUnlock(&t->waitable.mutex);
 }
 
-void _utimerRecalculate(UsermodeTimer* t, u64 old_tick)
+void _utimerRecalculate(UTimer* t, u64 old_tick)
 {
     mutexLock(&t->waitable.mutex);
 
@@ -68,7 +68,7 @@ void _utimerRecalculate(UsermodeTimer* t, u64 old_tick)
     mutexUnlock(&t->waitable.mutex);
 }
 
-u64 _utimerGetNextTick(UsermodeTimer* t)
+u64 _utimerGetNextTick(UTimer* t)
 {
     u64 ret;
 
@@ -79,7 +79,7 @@ u64 _utimerGetNextTick(UsermodeTimer* t)
     return ret;
 }
 
-void _utimerAddListener(UsermodeTimer* t, WaiterNode* w, size_t idx, size_t* idx_out, Handle thread)
+void _utimerAddListener(UTimer* t, WaiterNode* w, size_t idx, size_t* idx_out, Handle thread)
 {
     _waiterNodeCreate(w, WaiterNodeType_Timer, &t->waitable, thread, idx, idx_out);
 

nx/source/kernel/utimer.h

@@ -2,6 +2,6 @@
 #pragma once
 #include "kernel/utimer.h"
 
-void _utimerRecalculate(UsermodeTimer* t, u64 old_tick);
-u64  _utimerGetNextTick(UsermodeTimer* t);
-void _utimerAddListener(UsermodeTimer* t, WaiterNode* w, size_t idx, size_t* idx_out, Handle thread);
+void _utimerRecalculate(UTimer* t, u64 old_tick);
+u64  _utimerGetNextTick(UTimer* t);
+void _utimerAddListener(UTimer* t, WaiterNode* w, size_t idx, size_t* idx_out, Handle thread);

nx/source/kernel/wait.c

@@ -45,7 +45,7 @@ static Result waitImpl(s32* idx_out, Waiter* objects, size_t num_objects, u64 ti
 
         switch (obj->type)
         {
-        case WaiterType_UsermodeTimer:
+        case WaiterType_UTimer:
 
             timer_tick = _utimerGetNextTick(obj->timer);
 
@@ -79,7 +79,7 @@ static Result waitImpl(s32* idx_out, Waiter* objects, size_t num_objects, u64 ti
             num_waiters++;
             break;
 
-        case WaiterType_UsermodeEvent:
+        case WaiterType_UEvent:
 
             // Try to add a listener to the event, if it hasn't already signalled.
             added = _ueventAddListener(