Index: kernel/arch/abs32le/include/arch/asm.h =================================================================== --- kernel/arch/abs32le/include/arch/asm.h (revision bab75df6bdac0b39185034277416374a06d4b37f) +++ kernel/arch/abs32le/include/arch/asm.h (revision a6e55886e5b1f65fd811c2f746803ba53f061518) @@ -192,5 +192,5 @@ /* * 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 Index: kernel/generic/include/arch.h =================================================================== --- kernel/generic/include/arch.h (revision bab75df6bdac0b39185034277416374a06d4b37f) +++ kernel/generic/include/arch.h (revision a6e55886e5b1f65fd811c2f746803ba53f061518) @@ -40,10 +40,8 @@ /* - * 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 current_t structure holds pointers to various parts of the current + * execution state, 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,5 +51,5 @@ #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,5 +74,5 @@ struct as *as; /**< Current address space. */ uint32_t magic; /**< Magic value */ -} the_t; +} current_t; typedef struct { @@ -96,6 +94,6 @@ #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); Index: kernel/generic/include/cpu.h =================================================================== --- kernel/generic/include/cpu.h (revision bab75df6bdac0b39185034277416374a06d4b37f) +++ kernel/generic/include/cpu.h (revision a6e55886e5b1f65fd811c2f746803ba53f061518) @@ -45,5 +45,5 @@ #include -#define CPU THE->cpu +#define CPU CURRENT->cpu /** CPU structure. Index: kernel/generic/include/mm/as.h =================================================================== --- kernel/generic/include/mm/as.h (revision bab75df6bdac0b39185034277416374a06d4b37f) +++ kernel/generic/include/mm/as.h (revision a6e55886e5b1f65fd811c2f746803ba53f061518) @@ -50,5 +50,5 @@ #include -#define AS THE->as +#define AS CURRENT->as /** Index: kernel/generic/include/preemption.h =================================================================== --- kernel/generic/include/preemption.h (revision bab75df6bdac0b39185034277416374a06d4b37f) +++ kernel/generic/include/preemption.h (revision a6e55886e5b1f65fd811c2f746803ba53f061518) @@ -41,5 +41,5 @@ #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,5 +47,5 @@ #define preemption_disable() \ do { \ - THE->preemption += PREEMPTION_INC; \ + CURRENT->preemption += PREEMPTION_INC; \ compiler_barrier(); \ } while (0) @@ -56,5 +56,5 @@ assert(PREEMPTION_DISABLED); \ compiler_barrier(); \ - THE->preemption -= PREEMPTION_INC; \ + CURRENT->preemption -= PREEMPTION_INC; \ } while (0) Index: kernel/generic/include/proc/task.h =================================================================== --- kernel/generic/include/proc/task.h (revision bab75df6bdac0b39185034277416374a06d4b37f) +++ kernel/generic/include/proc/task.h (revision a6e55886e5b1f65fd811c2f746803ba53f061518) @@ -63,5 +63,5 @@ #include -#define TASK THE->task +#define TASK CURRENT->task struct thread; Index: kernel/generic/include/proc/thread.h =================================================================== --- kernel/generic/include/proc/thread.h (revision bab75df6bdac0b39185034277416374a06d4b37f) +++ kernel/generic/include/proc/thread.h (revision a6e55886e5b1f65fd811c2f746803ba53f061518) @@ -52,5 +52,5 @@ #include -#define THREAD THE->thread +#define THREAD CURRENT->thread #define THREAD_NAME_BUFLEN 20 Index: kernel/generic/include/synch/rcu.h =================================================================== --- kernel/generic/include/synch/rcu.h (revision bab75df6bdac0b39185034277416374a06d4b37f) +++ kernel/generic/include/synch/rcu.h (revision a6e55886e5b1f65fd811c2f746803ba53f061518) @@ -132,5 +132,5 @@ static inline void rcu_read_lock(void) { - THE->rcu_nesting += RCU_CNT_INC; + CURRENT->rcu_nesting += RCU_CNT_INC; compiler_barrier(); } @@ -140,7 +140,7 @@ { 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(); } Index: kernel/generic/include/time/timeout.h =================================================================== --- kernel/generic/include/time/timeout.h (revision bab75df6bdac0b39185034277416374a06d4b37f) +++ kernel/generic/include/time/timeout.h (revision a6e55886e5b1f65fd811c2f746803ba53f061518) @@ -45,5 +45,5 @@ 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. */ Index: kernel/generic/src/debug/panic.c =================================================================== --- kernel/generic/src/debug/panic.c (revision bab75df6bdac0b39185034277416374a06d4b37f) +++ kernel/generic/src/debug/panic.c (revision a6e55886e5b1f65fd811c2f746803ba53f061518) @@ -94,15 +94,15 @@ 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"); Index: kernel/generic/src/main/main.c =================================================================== --- kernel/generic/src/main/main.c (revision bab75df6bdac0b39185034277416374a06d4b37f) +++ kernel/generic/src/main/main.c (revision a6e55886e5b1f65fd811c2f746803ba53f061518) @@ -213,5 +213,5 @@ { /* Keep this the first thing. */ - the_initialize(THE); + current_initialize(CURRENT); version_print(); @@ -342,7 +342,7 @@ /* - * 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,5 +356,5 @@ ARCH_OP(post_cpu_init); - the_copy(THE, (the_t *) CPU->stack); + current_copy(CURRENT, (current_t *) CPU->stack); /* Index: kernel/generic/src/proc/scheduler.c =================================================================== --- kernel/generic/src/proc/scheduler.c (revision bab75df6bdac0b39185034277416374a06d4b37f) +++ kernel/generic/src/proc/scheduler.c (revision a6e55886e5b1f65fd811c2f746803ba53f061518) @@ -363,10 +363,10 @@ /* - * 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,5 +548,5 @@ * thread's stack. */ - the_copy(THE, (the_t *) THREAD->kstack); + current_copy(CURRENT, (current_t *) THREAD->kstack); context_restore(&THREAD->saved_context); Index: kernel/generic/src/proc/the.c =================================================================== --- kernel/generic/src/proc/the.c (revision bab75df6bdac0b39185034277416374a06d4b37f) +++ kernel/generic/src/proc/the.c (revision a6e55886e5b1f65fd811c2f746803ba53f061518) @@ -33,8 +33,8 @@ /** * @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,12 +45,12 @@ #include -/** 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,13 +65,13 @@ } -/** 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); Index: kernel/generic/src/proc/thread.c =================================================================== --- kernel/generic/src/proc/thread.c (revision bab75df6bdac0b39185034277416374a06d4b37f) +++ kernel/generic/src/proc/thread.c (revision a6e55886e5b1f65fd811c2f746803ba53f061518) @@ -356,5 +356,5 @@ (uintptr_t) thread->kstack, STACK_SIZE); - the_initialize((the_t *) thread->kstack); + current_initialize((current_t *) thread->kstack); ipl_t ipl = interrupts_disable(); Index: kernel/generic/src/synch/rcu.c =================================================================== --- kernel/generic/src/synch/rcu.c (revision bab75df6bdac0b39185034277416374a06d4b37f) +++ kernel/generic/src/synch/rcu.c (revision a6e55886e5b1f65fd811c2f746803ba53f061518) @@ -1026,5 +1026,5 @@ 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,5 +1054,5 @@ * 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,5 +1113,5 @@ /* 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,5 +1123,5 @@ void rcu_thread_exiting(void) { - assert(THE->rcu_nesting == 0); + assert(CURRENT->rcu_nesting == 0); /* @@ -1145,5 +1145,5 @@ bool rcu_read_locked(void) { - return RCU_CNT_INC <= THE->rcu_nesting; + return RCU_CNT_INC <= CURRENT->rcu_nesting; } @@ -1151,7 +1151,7 @@ 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) { /*