From 0d8da5ff930cffed6ff470850cdcebb5aeb11bfb Mon Sep 17 00:00:00 2001 From: Anas Nashif Date: Wed, 6 Mar 2024 15:59:36 -0500 Subject: [PATCH] kernel: rename scheduler spinlock variable and make it private rename sched_spinlock to _sched_spinglock to maintain it is privacy and to avoid any misuse. Signed-off-by: Anas Nashif --- kernel/cpu_mask.c | 4 +- kernel/include/ksched.h | 4 +- kernel/include/kswap.h | 14 ++--- kernel/mem_domain.c | 2 +- kernel/sched.c | 112 ++++++++++++++++++++-------------------- 5 files changed, 68 insertions(+), 68 deletions(-) diff --git a/kernel/cpu_mask.c b/kernel/cpu_mask.c index 99d8c4c3967..4efeb29035e 100644 --- a/kernel/cpu_mask.c +++ b/kernel/cpu_mask.c @@ -7,7 +7,7 @@ #include #include -extern struct k_spinlock sched_spinlock; +extern struct k_spinlock _sched_spinlock; # ifdef CONFIG_SMP @@ -25,7 +25,7 @@ static int cpu_mask_mod(k_tid_t thread, uint32_t enable_mask, uint32_t disable_m "Running threads cannot change CPU pin"); #endif - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { if (z_is_thread_prevented_from_running(thread)) { thread->base.cpu_mask |= enable_mask; thread->base.cpu_mask &= ~disable_mask; diff --git a/kernel/include/ksched.h b/kernel/include/ksched.h index d63de10c486..8a691acb815 100644 --- a/kernel/include/ksched.h +++ b/kernel/include/ksched.h @@ -277,7 +277,7 @@ static inline void z_sched_lock(void) * Given a wait_q, wake up the highest priority thread on the queue. If the * queue was empty just return false. * - * Otherwise, do the following, in order, holding sched_spinlock the entire + * Otherwise, do the following, in order, holding _sched_spinlock the entire * time so that the thread state is guaranteed not to change: * - Set the thread's swap return values to swap_retval and swap_data * - un-pend and ready the thread, but do not invoke the scheduler. @@ -363,7 +363,7 @@ int z_sched_wait(struct k_spinlock *lock, k_spinlock_key_t key, * @brief Walks the wait queue invoking the callback on each waiting thread * * This function walks the wait queue invoking the callback function on each - * waiting thread while holding sched_spinlock. This can be useful for routines + * waiting thread while holding _sched_spinlock. This can be useful for routines * that need to operate on multiple waiting threads. * * CAUTION! As a wait queue is of indeterminate length, the scheduler will be diff --git a/kernel/include/kswap.h b/kernel/include/kswap.h index 01a72744b00..862969ac79a 100644 --- a/kernel/include/kswap.h +++ b/kernel/include/kswap.h @@ -17,7 +17,7 @@ extern void z_check_stack_sentinel(void); #define z_check_stack_sentinel() /**/ #endif -extern struct k_spinlock sched_spinlock; +extern struct k_spinlock _sched_spinlock; /* In SMP, the irq_lock() is a spinlock which is implicitly released * and reacquired on context switch to preserve the existing @@ -112,11 +112,11 @@ static ALWAYS_INLINE unsigned int do_swap(unsigned int key, * have it. We "release" other spinlocks here. But we never * drop the interrupt lock. */ - if (is_spinlock && lock != NULL && lock != &sched_spinlock) { + if (is_spinlock && lock != NULL && lock != &_sched_spinlock) { k_spin_release(lock); } - if (!is_spinlock || lock != &sched_spinlock) { - (void) k_spin_lock(&sched_spinlock); + if (!is_spinlock || lock != &_sched_spinlock) { + (void) k_spin_lock(&_sched_spinlock); } new_thread = z_swap_next_thread(); @@ -141,7 +141,7 @@ static ALWAYS_INLINE unsigned int do_swap(unsigned int key, #endif #ifdef CONFIG_SPIN_VALIDATE - z_spin_lock_set_owner(&sched_spinlock); + z_spin_lock_set_owner(&_sched_spinlock); #endif arch_cohere_stacks(old_thread, NULL, new_thread); @@ -163,10 +163,10 @@ static ALWAYS_INLINE unsigned int do_swap(unsigned int key, new_thread->switch_handle = NULL; barrier_dmem_fence_full(); /* write barrier */ } - k_spin_release(&sched_spinlock); + k_spin_release(&_sched_spinlock); arch_switch(newsh, &old_thread->switch_handle); } else { - k_spin_release(&sched_spinlock); + k_spin_release(&_sched_spinlock); } if (is_spinlock) { diff --git a/kernel/mem_domain.c b/kernel/mem_domain.c index 268d218ce3e..fd8f05344a1 100644 --- a/kernel/mem_domain.c +++ b/kernel/mem_domain.c @@ -306,7 +306,7 @@ void z_mem_domain_init_thread(struct k_thread *thread) k_spin_unlock(&z_mem_domain_lock, key); } -/* Called when thread aborts during teardown tasks. sched_spinlock is held */ +/* Called when thread aborts during teardown tasks. _sched_spinlock is held */ void z_mem_domain_exit_thread(struct k_thread *thread) { int ret; diff --git a/kernel/sched.c b/kernel/sched.c index 47f05bf1609..a2f3e74bfa9 100644 --- a/kernel/sched.c +++ b/kernel/sched.c @@ -23,7 +23,7 @@ LOG_MODULE_DECLARE(os, CONFIG_KERNEL_LOG_LEVEL); -struct k_spinlock sched_spinlock; +struct k_spinlock _sched_spinlock; static void update_cache(int preempt_ok); static void halt_thread(struct k_thread *thread, uint8_t new_state); @@ -481,7 +481,7 @@ void z_reset_time_slice(struct k_thread *thread) void k_sched_time_slice_set(int32_t slice, int prio) { - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { slice_ticks = k_ms_to_ticks_ceil32(slice); slice_max_prio = prio; z_reset_time_slice(_current); @@ -492,7 +492,7 @@ void k_sched_time_slice_set(int32_t slice, int prio) void k_thread_time_slice_set(struct k_thread *thread, int32_t thread_slice_ticks, k_thread_timeslice_fn_t expired, void *data) { - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { thread->base.slice_ticks = thread_slice_ticks; thread->base.slice_expired = expired; thread->base.slice_data = data; @@ -503,13 +503,13 @@ void k_thread_time_slice_set(struct k_thread *thread, int32_t thread_slice_ticks /* Called out of each timer interrupt */ void z_time_slice(void) { - k_spinlock_key_t key = k_spin_lock(&sched_spinlock); + k_spinlock_key_t key = k_spin_lock(&_sched_spinlock); struct k_thread *curr = _current; #ifdef CONFIG_SWAP_NONATOMIC if (pending_current == curr) { z_reset_time_slice(curr); - k_spin_unlock(&sched_spinlock, key); + k_spin_unlock(&_sched_spinlock, key); return; } pending_current = NULL; @@ -518,9 +518,9 @@ void z_time_slice(void) if (slice_expired[_current_cpu->id] && sliceable(curr)) { #ifdef CONFIG_TIMESLICE_PER_THREAD if (curr->base.slice_expired) { - k_spin_unlock(&sched_spinlock, key); + k_spin_unlock(&_sched_spinlock, key); curr->base.slice_expired(curr, curr->base.slice_data); - key = k_spin_lock(&sched_spinlock); + key = k_spin_lock(&_sched_spinlock); } #endif if (!z_is_thread_prevented_from_running(curr)) { @@ -528,7 +528,7 @@ void z_time_slice(void) } z_reset_time_slice(curr); } - k_spin_unlock(&sched_spinlock, key); + k_spin_unlock(&_sched_spinlock, key); } #endif @@ -623,7 +623,7 @@ static void ready_thread(struct k_thread *thread) void z_ready_thread(struct k_thread *thread) { - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { if (!thread_active_elsewhere(thread)) { ready_thread(thread); } @@ -632,23 +632,23 @@ void z_ready_thread(struct k_thread *thread) void z_move_thread_to_end_of_prio_q(struct k_thread *thread) { - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { move_thread_to_end_of_prio_q(thread); } } void z_sched_start(struct k_thread *thread) { - k_spinlock_key_t key = k_spin_lock(&sched_spinlock); + k_spinlock_key_t key = k_spin_lock(&_sched_spinlock); if (z_has_thread_started(thread)) { - k_spin_unlock(&sched_spinlock, key); + k_spin_unlock(&_sched_spinlock, key); return; } z_mark_thread_as_started(thread); ready_thread(thread); - z_reschedule(&sched_spinlock, key); + z_reschedule(&_sched_spinlock, key); } /** @@ -664,7 +664,7 @@ void z_sched_start(struct k_thread *thread) * released before this routine returns. * * @param thread Thread to suspend or abort - * @param key Current key for sched_spinlock + * @param key Current key for _sched_spinlock * @param terminate True if aborting thread, false if suspending thread */ static void z_thread_halt(struct k_thread *thread, k_spinlock_key_t key, @@ -699,7 +699,7 @@ static void z_thread_halt(struct k_thread *thread, k_spinlock_key_t key, if (is_halting(thread) && (thread != _current)) { if (arch_is_in_isr()) { /* ISRs can only spin waiting another CPU */ - k_spin_unlock(&sched_spinlock, key); + k_spin_unlock(&_sched_spinlock, key); while (is_halting(thread)) { } @@ -707,25 +707,25 @@ static void z_thread_halt(struct k_thread *thread, k_spinlock_key_t key, * halted (suspended or aborted). Wait for the switch * to happen! */ - key = k_spin_lock(&sched_spinlock); + key = k_spin_lock(&_sched_spinlock); z_sched_switch_spin(thread); - k_spin_unlock(&sched_spinlock, key); + k_spin_unlock(&_sched_spinlock, key); } else if (active) { /* Threads can wait on a queue */ add_to_waitq_locked(_current, terminate ? &thread->join_queue : &thread->halt_queue); - z_swap(&sched_spinlock, key); + z_swap(&_sched_spinlock, key); } return; /* lock has been released */ } #endif halt_thread(thread, terminate ? _THREAD_DEAD : _THREAD_SUSPENDED); if ((thread == _current) && !arch_is_in_isr()) { - z_swap(&sched_spinlock, key); + z_swap(&_sched_spinlock, key); __ASSERT(!terminate, "aborted _current back from dead"); } else { - k_spin_unlock(&sched_spinlock, key); + k_spin_unlock(&_sched_spinlock, key); } } @@ -735,13 +735,13 @@ void z_impl_k_thread_suspend(struct k_thread *thread) (void)z_abort_thread_timeout(thread); - k_spinlock_key_t key = k_spin_lock(&sched_spinlock); + k_spinlock_key_t key = k_spin_lock(&_sched_spinlock); if ((thread->base.thread_state & _THREAD_SUSPENDED) != 0U) { /* The target thread is already suspended. Nothing to do. */ - k_spin_unlock(&sched_spinlock, key); + k_spin_unlock(&_sched_spinlock, key); return; } @@ -763,18 +763,18 @@ void z_impl_k_thread_resume(struct k_thread *thread) { SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_thread, resume, thread); - k_spinlock_key_t key = k_spin_lock(&sched_spinlock); + k_spinlock_key_t key = k_spin_lock(&_sched_spinlock); /* Do not try to resume a thread that was not suspended */ if (!z_is_thread_suspended(thread)) { - k_spin_unlock(&sched_spinlock, key); + k_spin_unlock(&_sched_spinlock, key); return; } z_mark_thread_as_not_suspended(thread); ready_thread(thread); - z_reschedule(&sched_spinlock, key); + z_reschedule(&_sched_spinlock, key); SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_thread, resume, thread); } @@ -803,7 +803,7 @@ static void unready_thread(struct k_thread *thread) update_cache(thread == _current); } -/* sched_spinlock must be held */ +/* _sched_spinlock must be held */ static void add_to_waitq_locked(struct k_thread *thread, _wait_q_t *wait_q) { unready_thread(thread); @@ -838,7 +838,7 @@ void z_pend_thread(struct k_thread *thread, _wait_q_t *wait_q, k_timeout_t timeout) { __ASSERT_NO_MSG(thread == _current || is_thread_dummy(thread)); - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { pend_locked(thread, wait_q, timeout); } } @@ -852,7 +852,7 @@ static inline void unpend_thread_no_timeout(struct k_thread *thread) ALWAYS_INLINE void z_unpend_thread_no_timeout(struct k_thread *thread) { - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { if (thread->base.pended_on != NULL) { unpend_thread_no_timeout(thread); } @@ -861,7 +861,7 @@ ALWAYS_INLINE void z_unpend_thread_no_timeout(struct k_thread *thread) void z_sched_wake_thread(struct k_thread *thread, bool is_timeout) { - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { bool killed = (thread->base.thread_state & (_THREAD_DEAD | _THREAD_ABORTING)); @@ -914,7 +914,7 @@ int z_pend_curr_irqlock(uint32_t key, _wait_q_t *wait_q, k_timeout_t timeout) pending_current = _current; int ret = z_swap_irqlock(key); - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { if (pending_current == _current) { pending_current = NULL; } @@ -931,7 +931,7 @@ int z_pend_curr(struct k_spinlock *lock, k_spinlock_key_t key, #if defined(CONFIG_TIMESLICING) && defined(CONFIG_SWAP_NONATOMIC) pending_current = _current; #endif - __ASSERT_NO_MSG(sizeof(sched_spinlock) == 0 || lock != &sched_spinlock); + __ASSERT_NO_MSG(sizeof(_sched_spinlock) == 0 || lock != &_sched_spinlock); /* We do a "lock swap" prior to calling z_swap(), such that * the caller's lock gets released as desired. But we ensure @@ -941,17 +941,17 @@ int z_pend_curr(struct k_spinlock *lock, k_spinlock_key_t key, * API that doesn't expect to be called with scheduler lock * held. */ - (void) k_spin_lock(&sched_spinlock); + (void) k_spin_lock(&_sched_spinlock); pend_locked(_current, wait_q, timeout); k_spin_release(lock); - return z_swap(&sched_spinlock, key); + return z_swap(&_sched_spinlock, key); } struct k_thread *z_unpend1_no_timeout(_wait_q_t *wait_q) { struct k_thread *thread = NULL; - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { thread = _priq_wait_best(&wait_q->waitq); if (thread != NULL) { @@ -966,7 +966,7 @@ struct k_thread *z_unpend_first_thread(_wait_q_t *wait_q) { struct k_thread *thread = NULL; - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { thread = _priq_wait_best(&wait_q->waitq); if (thread != NULL) { @@ -991,7 +991,7 @@ bool z_thread_prio_set(struct k_thread *thread, int prio) { bool need_sched = 0; - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { need_sched = z_is_thread_ready(thread); if (need_sched) { @@ -1063,7 +1063,7 @@ void z_reschedule_irqlock(uint32_t key) void k_sched_lock(void) { - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { SYS_PORT_TRACING_FUNC(k_thread, sched_lock); z_sched_lock(); @@ -1072,7 +1072,7 @@ void k_sched_lock(void) void k_sched_unlock(void) { - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { __ASSERT(_current->base.sched_locked != 0U, ""); __ASSERT(!arch_is_in_isr(), ""); @@ -1152,7 +1152,7 @@ void *z_get_next_switch_handle(void *interrupted) #ifdef CONFIG_SMP void *ret = NULL; - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { struct k_thread *old_thread = _current, *new_thread; if (IS_ENABLED(CONFIG_SMP)) { @@ -1180,7 +1180,7 @@ void *z_get_next_switch_handle(void *interrupted) * confused when the "wrong" thread tries to * release the lock. */ - z_spin_lock_set_owner(&sched_spinlock); + z_spin_lock_set_owner(&_sched_spinlock); #endif /* A queued (runnable) old/current thread @@ -1305,7 +1305,7 @@ void z_impl_k_thread_deadline_set(k_tid_t tid, int deadline) { struct k_thread *thread = tid; - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { thread->base.prio_deadline = k_cycle_get_32() + deadline; if (z_is_thread_queued(thread)) { dequeue_thread(thread); @@ -1342,7 +1342,7 @@ void z_impl_k_yield(void) SYS_PORT_TRACING_FUNC(k_thread, yield); - k_spinlock_key_t key = k_spin_lock(&sched_spinlock); + k_spinlock_key_t key = k_spin_lock(&_sched_spinlock); if (!IS_ENABLED(CONFIG_SMP) || z_is_thread_queued(_current)) { @@ -1350,7 +1350,7 @@ void z_impl_k_yield(void) } queue_thread(_current); update_cache(1); - z_swap(&sched_spinlock, key); + z_swap(&_sched_spinlock, key); } #ifdef CONFIG_USERSPACE @@ -1385,7 +1385,7 @@ static int32_t z_tick_sleep(k_ticks_t ticks) #ifdef CONFIG_MULTITHREADING k_timeout_t timeout = Z_TIMEOUT_TICKS(ticks); - k_spinlock_key_t key = k_spin_lock(&sched_spinlock); + k_spinlock_key_t key = k_spin_lock(&_sched_spinlock); #if defined(CONFIG_TIMESLICING) && defined(CONFIG_SWAP_NONATOMIC) pending_current = _current; @@ -1394,7 +1394,7 @@ static int32_t z_tick_sleep(k_ticks_t ticks) z_add_thread_timeout(_current, timeout); z_mark_thread_as_suspended(_current); - (void)z_swap(&sched_spinlock, key); + (void)z_swap(&_sched_spinlock, key); __ASSERT(!z_is_thread_state_set(_current, _THREAD_SUSPENDED), ""); @@ -1489,7 +1489,7 @@ void z_impl_k_wakeup(k_tid_t thread) } } - k_spinlock_key_t key = k_spin_lock(&sched_spinlock); + k_spinlock_key_t key = k_spin_lock(&_sched_spinlock); z_mark_thread_as_not_suspended(thread); @@ -1498,9 +1498,9 @@ void z_impl_k_wakeup(k_tid_t thread) } if (arch_is_in_isr()) { - k_spin_unlock(&sched_spinlock, key); + k_spin_unlock(&_sched_spinlock, key); } else { - z_reschedule(&sched_spinlock, key); + z_reschedule(&_sched_spinlock, key); } } @@ -1655,17 +1655,17 @@ static void halt_thread(struct k_thread *thread, uint8_t new_state) void z_thread_abort(struct k_thread *thread) { - k_spinlock_key_t key = k_spin_lock(&sched_spinlock); + k_spinlock_key_t key = k_spin_lock(&_sched_spinlock); if (z_is_thread_essential(thread)) { - k_spin_unlock(&sched_spinlock, key); + k_spin_unlock(&_sched_spinlock, key); __ASSERT(false, "aborting essential thread %p", thread); k_panic(); return; } if ((thread->base.thread_state & _THREAD_DEAD) != 0U) { - k_spin_unlock(&sched_spinlock, key); + k_spin_unlock(&_sched_spinlock, key); return; } @@ -1685,7 +1685,7 @@ void z_impl_k_thread_abort(struct k_thread *thread) int z_impl_k_thread_join(struct k_thread *thread, k_timeout_t timeout) { - k_spinlock_key_t key = k_spin_lock(&sched_spinlock); + k_spinlock_key_t key = k_spin_lock(&_sched_spinlock); int ret = 0; SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_thread, join, thread, timeout); @@ -1704,7 +1704,7 @@ int z_impl_k_thread_join(struct k_thread *thread, k_timeout_t timeout) add_thread_timeout(_current, timeout); SYS_PORT_TRACING_OBJ_FUNC_BLOCKING(k_thread, join, thread, timeout); - ret = z_swap(&sched_spinlock, key); + ret = z_swap(&_sched_spinlock, key); SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_thread, join, thread, timeout, ret); return ret; @@ -1712,7 +1712,7 @@ int z_impl_k_thread_join(struct k_thread *thread, k_timeout_t timeout) SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_thread, join, thread, timeout, ret); - k_spin_unlock(&sched_spinlock, key); + k_spin_unlock(&_sched_spinlock, key); return ret; } @@ -1777,7 +1777,7 @@ bool z_sched_wake(_wait_q_t *wait_q, int swap_retval, void *swap_data) struct k_thread *thread; bool ret = false; - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { thread = _priq_wait_best(&wait_q->waitq); if (thread != NULL) { @@ -1811,7 +1811,7 @@ int z_sched_waitq_walk(_wait_q_t *wait_q, struct k_thread *thread; int status = 0; - K_SPINLOCK(&sched_spinlock) { + K_SPINLOCK(&_sched_spinlock) { _WAIT_Q_FOR_EACH(wait_q, thread) { /*