From eb7d835a79f684fca51221d9d9e6e075686ae576 Mon Sep 17 00:00:00 2001 From: plutooo Date: Thu, 13 Dec 2018 22:56:11 +0100 Subject: [PATCH] wait: Rename UsermodeEvent and UsermodeTimer --- nx/include/switch/kernel/uevent.h | 16 ++++++++-------- nx/include/switch/kernel/utimer.h | 16 ++++++++-------- nx/include/switch/kernel/wait.h | 24 ++++++++++++------------ nx/source/kernel/uevent.c | 10 +++++----- nx/source/kernel/uevent.h | 4 ++-- nx/source/kernel/utimer.c | 12 ++++++------ nx/source/kernel/utimer.h | 6 +++--- nx/source/kernel/wait.c | 4 ++-- 8 files changed, 46 insertions(+), 46 deletions(-) diff --git a/nx/include/switch/kernel/uevent.h b/nx/include/switch/kernel/uevent.h index 623a1b11..db77f918 100644 --- a/nx/include/switch/kernel/uevent.h +++ b/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); diff --git a/nx/include/switch/kernel/utimer.h b/nx/include/switch/kernel/utimer.h index 280c11d3..165d978e 100644 --- a/nx/include/switch/kernel/utimer.h +++ b/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); diff --git a/nx/include/switch/kernel/wait.h b/nx/include/switch/kernel/wait.h index 575f7eee..d9e0bdc2 100644 --- a/nx/include/switch/kernel/wait.h +++ b/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; } diff --git a/nx/source/kernel/uevent.c b/nx/source/kernel/uevent.c index 05d14969..b384b0e3 100644 --- a/nx/source/kernel/uevent.c +++ b/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); diff --git a/nx/source/kernel/uevent.h b/nx/source/kernel/uevent.h index 49bd969a..bcd6b048 100644 --- a/nx/source/kernel/uevent.h +++ b/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); diff --git a/nx/source/kernel/utimer.c b/nx/source/kernel/utimer.c index f2307b2b..d2a1debd 100644 --- a/nx/source/kernel/utimer.c +++ b/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); diff --git a/nx/source/kernel/utimer.h b/nx/source/kernel/utimer.h index af3b77d8..fc03b964 100644 --- a/nx/source/kernel/utimer.h +++ b/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); diff --git a/nx/source/kernel/wait.c b/nx/source/kernel/wait.c index b3dc81c7..c967a070 100644 --- a/nx/source/kernel/wait.c +++ b/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(