Replace "awaken" with "awoken"

See https://www.merriam-webster.com/words-at-play/usage-awaken-awoken-awakened.

10 files changed, 16 insertions, 16 deletions

diff --git a/kern/semaphore.h b/kern/semaphore.h
index a18e4701..708417a8 100644
--- a/kern/semaphore.h
+++ b/kern/semaphore.h
@@ -88,7 +88,7 @@ int semaphore_timedwait(struct semaphore *semaphore, uint64_t ticks);
  * Signal a semaphore.
  *
  * This function attempts to increment the semaphore value. If successful, and
- * if one or more threads are waiting on the semaphore, one of them is awaken.
+ * if one or more threads are waiting on the semaphore, one of them is awoken.
  *
  * A semaphore may safely be signalled from interrupt context.
  *
diff --git a/kern/sleepq.c b/kern/sleepq.c
index 8abd84c4..2ed7ef2d 100644
--- a/kern/sleepq.c
+++ b/kern/sleepq.c
@@ -571,7 +571,7 @@ sleepq_wait_common(struct sleepq *sleepq, const char *wchan,
     next = sleepq_get_last_waiter(sleepq);
 
     /*
-     * Checking against the oldest waiter is enough as waiters are awaken
+     * Checking against the oldest waiter is enough as waiters are awoken
      * in strict FIFO order.
      */
     if (next && (next != sleepq->oldest_waiter)) {
diff --git a/kern/sleepq.h b/kern/sleepq.h
index f866d0bd..68421992 100644
--- a/kern/sleepq.h
+++ b/kern/sleepq.h
@@ -84,7 +84,7 @@ void sleepq_release_intr_restore(struct sleepq *sleepq,
  *
  * When multiple threads lend their sleep queue for the same synchronization
  * object, the extra queues lent are kept in an internal free list, used
- * when threads are awaken to return a queue to them. As a result, the
+ * when threads are awoken to return a queue to them. As a result, the
  * sleep queue returned may not be the one lent.
  *
  * The sleep queue obtained when lending is automatically acquired.
@@ -139,7 +139,7 @@ int sleepq_timedwait(struct sleepq *sleepq, const char *wchan, uint64_t ticks);
  * acquired) when waiting, and acquired in order to signal it,
  * wake-ups are serialized and cannot be missed.
  *
- * At least one thread is awaken if any threads are waiting on the sleep
+ * At least one thread is awoken if any threads are waiting on the sleep
  * queue.
  *
  * Broadcasting a sleep queue wakes up all waiting threads.
diff --git a/kern/sref.h b/kern/sref.h
index e224d167..93de1c35 100644
--- a/kern/sref.h
+++ b/kern/sref.h
@@ -61,7 +61,7 @@ typedef void (*sref_noref_fn_t)(struct sref_counter *);
  * impossible to obtain or release references while idling.
  *
  * Unregistration can fail if internal data still require processing, in
- * which case a maintenance thread is awaken and EBUSY is returned.
+ * which case a maintenance thread is awoken and EBUSY is returned.
  *
  * Preemption must be disabled when calling these functions.
  */
diff --git a/kern/thread.c b/kern/thread.c
index 498aae41..d592b72e 100644
--- a/kern/thread.c
+++ b/kern/thread.c
@@ -1545,7 +1545,7 @@ static struct thread_runq *
 thread_sched_idle_select_runq(struct thread *thread)
 {
     (void)thread;
-    panic("thread: idler threads cannot be awaken");
+    panic("thread: idler threads cannot be awoken");
 }
 
 static noreturn void
diff --git a/kern/thread.h b/kern/thread.h
index 06dcad73..a65b4999 100644
--- a/kern/thread.h
+++ b/kern/thread.h
@@ -225,7 +225,7 @@ void thread_join(struct thread *thread);
  *
  * When bounding the duration of the sleep, the caller must pass an absolute
  * time in ticks, and ETIMEDOUT is returned if that time is reached before
- * the thread is awaken.
+ * the thread is awoken.
  *
  * Implies a memory barrier.
  */
diff --git a/kern/thread_i.h b/kern/thread_i.h
index 21f92a29..253998dc 100644
--- a/kern/thread_i.h
+++ b/kern/thread_i.h
@@ -164,7 +164,7 @@ struct thread {
      *     sets its state to dead before calling the scheduler.
      *  2/ Another thread must either already be joining, or join later.
      *     When the thread reference counter drops to zero, the terminating
-     *     flag is set, and the joining thread is awaken, if any. After that,
+     *     flag is set, and the joining thread is awoken, if any. After that,
      *     the join operation polls the state until it sees the target thread
      *     as dead, and then releases its resources.
      */
diff --git a/kern/turnstile.c b/kern/turnstile.c
index 29073615..b0341f9c 100644
--- a/kern/turnstile.c
+++ b/kern/turnstile.c
@@ -108,7 +108,7 @@ struct turnstile {
 struct turnstile_waiter {
     struct plist_node node; /* (b,t) */
     struct thread *thread;  /* (b,t) */
-    bool awaken;            /* (b)   */
+    bool awoken;            /* (b)   */
 };
 
 #define TURNSTILE_HTABLE_SIZE 128
@@ -134,7 +134,7 @@ turnstile_waiter_init(struct turnstile_waiter *waiter, struct thread *thread)
 {
     plist_node_init(&waiter->node, thread_real_global_priority(thread));
     waiter->thread = thread;
-    waiter->awaken = false;
+    waiter->awoken = false;
 }
 
 static unsigned int
@@ -146,19 +146,19 @@ turnstile_waiter_priority(const struct turnstile_waiter *waiter)
 static bool
 turnstile_waiter_awaken(const struct turnstile_waiter *waiter)
 {
-    return waiter->awaken;
+    return waiter->awoken;
 }
 
 static void
 turnstile_waiter_set_awaken(struct turnstile_waiter *waiter)
 {
-    waiter->awaken = true;
+    waiter->awoken = true;
 }
 
 static void
 turnstile_waiter_clear_awaken(struct turnstile_waiter *waiter)
 {
-    waiter->awaken = false;
+    waiter->awoken = false;
 }
 
 static void
@@ -756,7 +756,7 @@ turnstile_wait_common(struct turnstile *turnstile, const char *wchan,
             break;
         }
 
-        /* Otherwise, make sure the new top waiter is awaken */
+        /* Otherwise, make sure the new top waiter is awoken */
         turnstile_waiter_wakeup(turnstile->top_waiter);
         turnstile_waiter_clear_awaken(&waiter);
     }
diff --git a/kern/turnstile.h b/kern/turnstile.h
index 929bdd50..3ff90a45 100644
--- a/kern/turnstile.h
+++ b/kern/turnstile.h
@@ -130,7 +130,7 @@ void turnstile_release(struct turnstile *turnstile);
  *
  * When multiple threads are waiting on the same turnstile, the extra
  * turnstiles lent are kept in an internal free list, used when threads
- * are awaken to return a turnstile to them.
+ * are awoken to return a turnstile to them.
  *
  * Note that the turnstile returned may not be the one lent.
  *
diff --git a/test/test_mutex_pi.c b/test/test_mutex_pi.c
index 4332a91d..5ddcfa70 100644
--- a/test/test_mutex_pi.c
+++ b/test/test_mutex_pi.c
@@ -66,7 +66,7 @@
  * the least and should be the most frequent to report progress. Because of
  * contention from B, D and E on M3, D rarely gets boosted. The reason is
  * that, when B owns the mutex, E is likely to wait on M3 soon enough that
- * it will be awaken before D, preventing the conditions for priority
+ * it will be awoken before D, preventing the conditions for priority
  * inheritance to occur.
  *
  * Note that the test uses regular mutexes instead of real-time mutexes,