Changeset 91a8f83 in mainline

Timestamp:

2018-10-31T18:15:56Z (6 years ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Children:

071cb36

Parents:

482f968

Message:

Rename THE/the_t to CURRENT/current_t

Because the word "THE" occurs several times in every licence
header, searching for occurences of "THE" macro is more difficult
than necessary.

While I appreciate the wit of it, using a nonconflicting word
for it is more practical.

Location:

kernel

Files:

• arch/abs32le/include/arch/asm.h (modified) (1 diff)
• generic/include/arch.h (modified) (4 diffs)
• generic/include/cpu.h (modified) (1 diff)
• generic/include/mm/as.h (modified) (1 diff)
• generic/include/preemption.h (modified) (3 diffs)
• generic/include/proc/task.h (modified) (1 diff)
• generic/include/proc/thread.h (modified) (1 diff)
• generic/include/synch/rcu.h (modified) (2 diffs)
• generic/include/time/timeout.h (modified) (1 diff)
• generic/src/debug/panic.c (modified) (1 diff)
• generic/src/main/main.c (modified) (3 diffs)
• generic/src/proc/scheduler.c (modified) (2 diffs)
• generic/src/proc/the.c (modified) (3 diffs)
• generic/src/proc/thread.c (modified) (1 diff)
• generic/src/synch/rcu.c (modified) (6 diffs)

kernel/arch/abs32le/include/arch/asm.h

@@ -192 +192 @@
         /*
          * On real hardware this returns the address of the bottom
-         * of the current CPU stack. The the_t structure is stored
+         * of the current CPU stack. The current_t structure is stored
          * on the bottom of stack and this is used to identify the
          * current CPU, current task, current thread and current

kernel/generic/include/arch.h

@@ -40 +40 @@
 
 /*
- * THE is not an abbreviation, but the English definite article written in
- * capital letters. It means the current pointer to something, e.g. thread,
- * processor or address space. Kind reader of this comment shall appreciate
- * the wit of constructs like THE->thread and similar.
+ * The context pointer. The current_t structure holds pointers to various parts
+ * of the current execution context, like running task, thread, address space,
+ * etc.
  */
-#define THE  ((the_t * )(get_stack_base()))
+#define CURRENT  ((current_t * )(get_stack_base()))
 
 #define MAGIC                UINT32_C(0xfacefeed)
@@ -53 +52 @@
 #define DEFAULT_CONTAINER  0
 #define CONTAINER \
-        ((THE->task) ? (THE->task->container) : (DEFAULT_CONTAINER))
+        ((CURRENT->task) ? (CURRENT->task->container) : (DEFAULT_CONTAINER))
 
 /* Fwd decl. to avoid include hell. */
@@ -76 +75 @@
         struct as *as;         /**< Current address space. */
         uint32_t magic;        /**< Magic value */
-} the_t;
+} current_t;
 
 typedef struct {
@@ -96 +95 @@
 #define ARCH_OP(op)     ARCH_STRUCT_OP(arch_ops, op)
 
-extern void the_initialize(the_t *);
-extern void the_copy(the_t *, the_t *);
+extern void current_initialize(current_t *);
+extern void current_copy(current_t *, current_t *);
 
 extern void calibrate_delay_loop(void);

kernel/generic/include/cpu.h

@@ -45 +45 @@
 #include <arch.h>
 
-#define CPU                  THE->cpu
+#define CPU                  CURRENT->cpu
 
 /** CPU structure.

kernel/generic/include/mm/as.h

@@ -50 +50 @@
 #include <lib/refcount.h>
 
-#define AS                   THE->as
+#define AS                   CURRENT->as
 
 /**

kernel/generic/include/preemption.h

@@ -41 +41 @@
 
 #define PREEMPTION_INC         (1 << 0)
-#define PREEMPTION_DISABLED    (PREEMPTION_INC <= THE->preemption)
+#define PREEMPTION_DISABLED    (PREEMPTION_INC <= CURRENT->preemption)
 #define PREEMPTION_ENABLED     (!PREEMPTION_DISABLED)
 
@@ -47 +47 @@
 #define preemption_disable() \
         do { \
-                THE->preemption += PREEMPTION_INC; \
+                CURRENT->preemption += PREEMPTION_INC; \
                 compiler_barrier(); \
         } while (0)
@@ -56 +56 @@
                 assert(PREEMPTION_DISABLED); \
                 compiler_barrier(); \
-                THE->preemption -= PREEMPTION_INC; \
+                CURRENT->preemption -= PREEMPTION_INC; \
         } while (0)
 

kernel/generic/include/proc/task.h

@@ -63 +63 @@
 #include <cap/cap.h>
 
-#define TASK                 THE->task
+#define TASK                 CURRENT->task
 
 struct thread;

kernel/generic/include/proc/thread.h

@@ -52 +52 @@
 #include <arch.h>
 
-#define THREAD              THE->thread
+#define THREAD              CURRENT->thread
 
 #define THREAD_NAME_BUFLEN  20

kernel/generic/include/synch/rcu.h

@@ -132 +132 @@
 static inline void rcu_read_lock(void)
 {
-        THE->rcu_nesting += RCU_CNT_INC;
+        CURRENT->rcu_nesting += RCU_CNT_INC;
         compiler_barrier();
 }
@@ -140 +140 @@
 {
         compiler_barrier();
-        THE->rcu_nesting -= RCU_CNT_INC;
-
-        if (RCU_WAS_PREEMPTED == THE->rcu_nesting) {
+        CURRENT->rcu_nesting -= RCU_CNT_INC;
+
+        if (RCU_WAS_PREEMPTED == CURRENT->rcu_nesting) {
                 _rcu_preempted_unlock();
         }

kernel/generic/include/time/timeout.h

@@ -45 +45 @@
         IRQ_SPINLOCK_DECLARE(lock);
 
-        /** Link to the list of active timeouts on THE->cpu */
+        /** Link to the list of active timeouts on CURRENT->cpu */
         link_t link;
         /** Timeout will be activated in this amount of clock() ticks. */

kernel/generic/src/debug/panic.c

@@ -94 +94 @@
         printf("\n");
 
-        printf("THE=%p: ", THE);
-        if (THE != NULL) {
+        printf("CURRENT=%p: ", CURRENT);
+        if (CURRENT != NULL) {
                 printf("pe=%" PRIuPTR " thread=%p task=%p cpu=%p as=%p"
-                    " magic=%#" PRIx32 "\n", THE->preemption,
-                    THE->thread, THE->task, THE->cpu, THE->as, THE->magic);
+                    " magic=%#" PRIx32 "\n", CURRENT->preemption,
+                    CURRENT->thread, CURRENT->task, CURRENT->cpu, CURRENT->as, CURRENT->magic);
 
-                if (THE->thread != NULL)
-                        printf("thread=\"%s\"\n", THE->thread->name);
+                if (CURRENT->thread != NULL)
+                        printf("thread=\"%s\"\n", CURRENT->thread->name);
 
-                if (THE->task != NULL)
-                        printf("task=\"%s\"\n", THE->task->name);
+                if (CURRENT->task != NULL)
+                        printf("task=\"%s\"\n", CURRENT->task->name);
         } else
                 printf("invalid\n");

kernel/generic/src/main/main.c

@@ -213 +213 @@
 {
         /* Keep this the first thing. */
-        the_initialize(THE);
+        current_initialize(CURRENT);
 
         version_print();
@@ -342 +342 @@
 
         /*
-         * The THE structure is well defined because ctx.sp is used as stack.
-         */
-        the_initialize(THE);
+         * The CURRENT structure is well defined because ctx.sp is used as stack.
+         */
+        current_initialize(CURRENT);
 
         ARCH_OP(pre_mm_init);
@@ -356 +356 @@
         ARCH_OP(post_cpu_init);
 
-        the_copy(THE, (the_t *) CPU->stack);
+        current_copy(CURRENT, (current_t *) CPU->stack);
 
         /*

kernel/generic/src/proc/scheduler.c

@@ -363 +363 @@
 
         /*
-         * Through the 'THE' structure, we keep track of THREAD, TASK, CPU, AS
-         * and preemption counter. At this point THE could be coming either
+         * Through the 'CURRENT' structure, we keep track of THREAD, TASK, CPU, AS
+         * and preemption counter. At this point CURRENT could be coming either
          * from THREAD's or CPU's stack.
          *
          */
-        the_copy(THE, (the_t *) CPU->stack);
+        current_copy(CURRENT, (current_t *) CPU->stack);
 
         /*
@@ -548 +548 @@
          * thread's stack.
          */
-        the_copy(THE, (the_t *) THREAD->kstack);
+        current_copy(CURRENT, (current_t *) THREAD->kstack);
 
         context_restore(&THREAD->saved_context);

kernel/generic/src/proc/the.c

@@ -33 +33 @@
 /**
  * @file
- * @brief THE structure functions.
+ * @brief CURRENT structure functions.
  *
- * This file contains functions to manage the THE structure.
- * The THE structure exists at the base address of every kernel
+ * This file contains functions to manage the CURRENT structure.
+ * The CURRENT structure exists at the base address of every kernel
  * stack and carries information about current settings
  * (e.g. current CPU, current thread, task and address space
@@ -45 +45 @@
 #include <assert.h>
 
-/** Initialize THE structure
+/** Initialize CURRENT structure
  *
- * Initialize THE structure passed as argument.
+ * Initialize CURRENT structure passed as argument.
  *
- * @param the THE structure to be initialized.
+ * @param the CURRENT structure to be initialized.
  *
  */
-void the_initialize(the_t *the)
+void current_initialize(current_t *the)
 {
         the->preemption = 0;
@@ -65 +65 @@
 }
 
-/** Copy THE structure
+/** Copy CURRENT structure
  *
- * Copy the source THE structure to the destination THE structure.
+ * Copy the source CURRENT structure to the destination CURRENT structure.
  *
- * @param src The source THE structure.
- * @param dst The destination THE structure.
+ * @param src The source CURRENT structure.
+ * @param dst The destination CURRENT structure.
  *
  */
-NO_TRACE void the_copy(the_t *src, the_t *dst)
+NO_TRACE void current_copy(current_t *src, current_t *dst)
 {
         assert(src->magic == MAGIC);

kernel/generic/src/proc/thread.c

@@ -356 +356 @@
             (uintptr_t) thread->kstack, STACK_SIZE);
 
-        the_initialize((the_t *) thread->kstack);
+        current_initialize((current_t *) thread->kstack);
 
         ipl_t ipl = interrupts_disable();

kernel/generic/src/synch/rcu.c

@@ -1026 +1026 @@
         cpu_mask_t *reader_cpus = (cpu_mask_t *)arg;
 
-        bool locked = RCU_CNT_INC <= THE->rcu_nesting;
+        bool locked = RCU_CNT_INC <= CURRENT->rcu_nesting;
         /* smp_call machinery makes the most current _rcu_cur_gp visible. */
         bool passed_qs = (CPU->rcu.last_seen_gp == _rcu_cur_gp);
@@ -1054 +1054 @@
          * with a local copy.
          */
-        size_t nesting_cnt = local_atomic_exchange(&THE->rcu_nesting, 0);
+        size_t nesting_cnt = local_atomic_exchange(&CURRENT->rcu_nesting, 0);
 
         /*
@@ -1113 +1113 @@
 
         /* Load the thread's saved nesting count from before it was preempted. */
-        THE->rcu_nesting = THREAD->rcu.nesting_cnt;
+        CURRENT->rcu_nesting = THREAD->rcu.nesting_cnt;
 }
 
@@ -1123 +1123 @@
 void rcu_thread_exiting(void)
 {
-        assert(THE->rcu_nesting == 0);
+        assert(CURRENT->rcu_nesting == 0);
 
         /*
@@ -1145 +1145 @@
 bool rcu_read_locked(void)
 {
-        return RCU_CNT_INC <= THE->rcu_nesting;
+        return RCU_CNT_INC <= CURRENT->rcu_nesting;
 }
 
@@ -1151 +1151 @@
 void _rcu_preempted_unlock(void)
 {
-        assert(0 == THE->rcu_nesting || RCU_WAS_PREEMPTED == THE->rcu_nesting);
-
-        size_t prev = local_atomic_exchange(&THE->rcu_nesting, 0);
+        assert(0 == CURRENT->rcu_nesting || RCU_WAS_PREEMPTED == CURRENT->rcu_nesting);
+
+        size_t prev = local_atomic_exchange(&CURRENT->rcu_nesting, 0);
         if (prev == RCU_WAS_PREEMPTED) {
                 /*