Index: kernel/arch/mips32/src/mips32.c =================================================================== --- kernel/arch/mips32/src/mips32.c (revision 95658c95a818a8da0be5aa39b51a70c6274f733a) +++ kernel/arch/mips32/src/mips32.c (revision f43d8cef17ca84bb86ea598fe7053f90fc5d9fa0) @@ -41,4 +41,5 @@ #include #include +#include #include #include Index: kernel/arch/ppc32/src/mm/frame.c =================================================================== --- kernel/arch/ppc32/src/mm/frame.c (revision 95658c95a818a8da0be5aa39b51a70c6274f733a) +++ kernel/arch/ppc32/src/mm/frame.c (revision f43d8cef17ca84bb86ea598fe7053f90fc5d9fa0) @@ -33,4 +33,5 @@ */ +#include #include #include Index: kernel/generic/include/mm/tlb.h =================================================================== --- kernel/generic/include/mm/tlb.h (revision 95658c95a818a8da0be5aa39b51a70c6274f733a) +++ kernel/generic/include/mm/tlb.h (revision f43d8cef17ca84bb86ea598fe7053f90fc5d9fa0) @@ -36,4 +36,5 @@ #define KERN_TLB_H_ +#include #include #include Index: kernel/generic/include/synch/spinlock.h =================================================================== --- kernel/generic/include/synch/spinlock.h (revision 95658c95a818a8da0be5aa39b51a70c6274f733a) +++ kernel/generic/include/synch/spinlock.h (revision f43d8cef17ca84bb86ea598fe7053f90fc5d9fa0) @@ -1,4 +1,5 @@ /* * Copyright (c) 2001-2004 Jakub Jermar + * Copyright (c) 2023 Jiří Zárevúcky * All rights reserved. * @@ -36,108 +37,15 @@ #define KERN_SPINLOCK_H_ -#include #include #include -#include -#include -#ifdef CONFIG_SMP +#include +#include -typedef struct spinlock { - atomic_flag flag; +#define DEADLOCK_THRESHOLD 100000000 -#ifdef CONFIG_DEBUG_SPINLOCK - const char *name; -#endif /* CONFIG_DEBUG_SPINLOCK */ -} spinlock_t; - -/* - * SPINLOCK_DECLARE is to be used for dynamically allocated spinlocks, - * where the lock gets initialized in run time. - */ -#define SPINLOCK_DECLARE(lock_name) spinlock_t lock_name -#define SPINLOCK_EXTERN(lock_name) extern spinlock_t lock_name - -/* - * SPINLOCK_INITIALIZE and SPINLOCK_STATIC_INITIALIZE are to be used - * for statically allocated spinlocks. They declare (either as global - * or static) symbol and initialize the lock. - */ -#ifdef CONFIG_DEBUG_SPINLOCK - -#define SPINLOCK_INITIALIZE_NAME(lock_name, desc_name) \ - spinlock_t lock_name = { \ - .name = desc_name, \ - .flag = ATOMIC_FLAG_INIT \ - } - -#define SPINLOCK_STATIC_INITIALIZE_NAME(lock_name, desc_name) \ - static spinlock_t lock_name = { \ - .name = desc_name, \ - .flag = ATOMIC_FLAG_INIT \ - } - -#define ASSERT_SPINLOCK(expr, lock) \ - assert_verbose(expr, (lock)->name) - -#define spinlock_lock(lock) spinlock_lock_debug((lock)) -#define spinlock_unlock(lock) spinlock_unlock_debug((lock)) - -#else /* CONFIG_DEBUG_SPINLOCK */ - -#define SPINLOCK_INITIALIZE_NAME(lock_name, desc_name) \ - spinlock_t lock_name = { \ - .flag = ATOMIC_FLAG_INIT \ - } - -#define SPINLOCK_STATIC_INITIALIZE_NAME(lock_name, desc_name) \ - static spinlock_t lock_name = { \ - .flag = ATOMIC_FLAG_INIT \ - } - -#define ASSERT_SPINLOCK(expr, lock) \ - assert(expr) - -/** Acquire spinlock - * - * @param lock Pointer to spinlock_t structure. - */ -_NO_TRACE static inline void spinlock_lock(spinlock_t *lock) -{ - preemption_disable(); - while (atomic_flag_test_and_set_explicit(&lock->flag, - memory_order_acquire)) - ; -} - -/** Release spinlock - * - * @param lock Pointer to spinlock_t structure. - */ -_NO_TRACE static inline void spinlock_unlock(spinlock_t *lock) -{ - atomic_flag_clear_explicit(&lock->flag, memory_order_release); - preemption_enable(); -} - -#endif /* CONFIG_DEBUG_SPINLOCK */ - -#define SPINLOCK_INITIALIZE(lock_name) \ - SPINLOCK_INITIALIZE_NAME(lock_name, #lock_name) - -#define SPINLOCK_STATIC_INITIALIZE(lock_name) \ - SPINLOCK_STATIC_INITIALIZE_NAME(lock_name, #lock_name) - -extern void spinlock_initialize(spinlock_t *, const char *); -extern bool spinlock_trylock(spinlock_t *); -extern void spinlock_lock_debug(spinlock_t *); -extern void spinlock_unlock_debug(spinlock_t *); -extern bool spinlock_locked(spinlock_t *); - -#ifdef CONFIG_DEBUG_SPINLOCK +#if defined(CONFIG_SMP) && defined(CONFIG_DEBUG_SPINLOCK) #include - -#define DEADLOCK_THRESHOLD 100000000 #define DEADLOCK_PROBE_INIT(pname) size_t pname = 0 @@ -159,37 +67,62 @@ #endif /* CONFIG_DEBUG_SPINLOCK */ -#else /* CONFIG_SMP */ +typedef struct spinlock { +#ifdef CONFIG_SMP + atomic_flag flag; -/* On UP systems, spinlocks are effectively left out. */ +#ifdef CONFIG_DEBUG_SPINLOCK + const char *name; +#endif /* CONFIG_DEBUG_SPINLOCK */ +#endif +} spinlock_t; -/* Allow the use of spinlock_t as an incomplete type. */ -typedef struct spinlock spinlock_t; +/* + * SPINLOCK_DECLARE is to be used for dynamically allocated spinlocks, + * where the lock gets initialized in run time. + */ +#define SPINLOCK_DECLARE(lock_name) spinlock_t lock_name +#define SPINLOCK_EXTERN(lock_name) extern spinlock_t lock_name -#define SPINLOCK_DECLARE(name) -#define SPINLOCK_EXTERN(name) +#ifdef CONFIG_SMP +#ifdef CONFIG_DEBUG_SPINLOCK +#define SPINLOCK_INITIALIZER(desc_name) { .name = (desc_name), .flag = ATOMIC_FLAG_INIT } +#else +#define SPINLOCK_INITIALIZER(desc_name) { .flag = ATOMIC_FLAG_INIT } +#endif +#else +#define SPINLOCK_INITIALIZER(desc_name) {} +#endif -#define SPINLOCK_INITIALIZE(name) -#define SPINLOCK_STATIC_INITIALIZE(name) +/* + * SPINLOCK_INITIALIZE and SPINLOCK_STATIC_INITIALIZE are to be used + * for statically allocated spinlocks. They declare (either as global + * or static) symbol and initialize the lock. + */ +#define SPINLOCK_INITIALIZE_NAME(lock_name, desc_name) \ + spinlock_t lock_name = SPINLOCK_INITIALIZER(desc_name) -#define SPINLOCK_INITIALIZE_NAME(name, desc_name) -#define SPINLOCK_STATIC_INITIALIZE_NAME(name, desc_name) +#define SPINLOCK_STATIC_INITIALIZE_NAME(lock_name, desc_name) \ + static spinlock_t lock_name = SPINLOCK_INITIALIZER(desc_name) -#define ASSERT_SPINLOCK(expr, lock) assert(expr) +#if defined(CONFIG_SMP) && defined(CONFIG_DEBUG_SPINLOCK) +#define ASSERT_SPINLOCK(expr, lock) assert_verbose(expr, (lock)->name) +#else /* CONFIG_DEBUG_SPINLOCK */ +#define ASSERT_SPINLOCK(expr, lock) assert(expr) +#endif /* CONFIG_DEBUG_SPINLOCK */ -#define spinlock_initialize(lock, name) +#define SPINLOCK_INITIALIZE(lock_name) \ + SPINLOCK_INITIALIZE_NAME(lock_name, #lock_name) -#define spinlock_lock(lock) preemption_disable() -#define spinlock_trylock(lock) ({ preemption_disable(); 1; }) -#define spinlock_unlock(lock) preemption_enable() -#define spinlock_locked(lock) 1 -#define spinlock_unlocked(lock) 1 +#define SPINLOCK_STATIC_INITIALIZE(lock_name) \ + SPINLOCK_STATIC_INITIALIZE_NAME(lock_name, #lock_name) -#define DEADLOCK_PROBE_INIT(pname) -#define DEADLOCK_PROBE(pname, value) - -#endif /* CONFIG_SMP */ +extern void spinlock_initialize(spinlock_t *, const char *); +extern bool spinlock_trylock(spinlock_t *); +extern void spinlock_lock(spinlock_t *); +extern void spinlock_unlock(spinlock_t *); +extern bool spinlock_locked(spinlock_t *); typedef struct { - SPINLOCK_DECLARE(lock); /**< Spinlock */ + spinlock_t lock; /**< Spinlock */ bool guard; /**< Flag whether ipl is valid */ ipl_t ipl; /**< Original interrupt level */ @@ -199,8 +132,13 @@ #define IRQ_SPINLOCK_EXTERN(lock_name) extern irq_spinlock_t lock_name -#ifdef CONFIG_SMP - #define ASSERT_IRQ_SPINLOCK(expr, irq_lock) \ ASSERT_SPINLOCK(expr, &((irq_lock)->lock)) + +#define IRQ_SPINLOCK_INITIALIZER(desc_name) \ + { \ + .lock = SPINLOCK_INITIALIZER(desc_name), \ + .guard = false, \ + .ipl = 0, \ + } /* @@ -209,72 +147,9 @@ * as global or static symbol) and initialize the lock. */ -#ifdef CONFIG_DEBUG_SPINLOCK - #define IRQ_SPINLOCK_INITIALIZE_NAME(lock_name, desc_name) \ - irq_spinlock_t lock_name = { \ - .lock = { \ - .name = desc_name, \ - .flag = ATOMIC_FLAG_INIT \ - }, \ - .guard = false, \ - .ipl = 0 \ - } + irq_spinlock_t lock_name = IRQ_SPINLOCK_INITIALIZER(desc_name) #define IRQ_SPINLOCK_STATIC_INITIALIZE_NAME(lock_name, desc_name) \ - static irq_spinlock_t lock_name = { \ - .lock = { \ - .name = desc_name, \ - .flag = ATOMIC_FLAG_INIT \ - }, \ - .guard = false, \ - .ipl = 0 \ - } - -#else /* CONFIG_DEBUG_SPINLOCK */ - -#define IRQ_SPINLOCK_INITIALIZE_NAME(lock_name, desc_name) \ - irq_spinlock_t lock_name = { \ - .lock = { \ - .flag = ATOMIC_FLAG_INIT \ - }, \ - .guard = false, \ - .ipl = 0 \ - } - -#define IRQ_SPINLOCK_STATIC_INITIALIZE_NAME(lock_name, desc_name) \ - static irq_spinlock_t lock_name = { \ - .lock = { \ - .flag = ATOMIC_FLAG_INIT \ - }, \ - .guard = false, \ - .ipl = 0 \ - } - -#endif /* CONFIG_DEBUG_SPINLOCK */ - -#else /* CONFIG_SMP */ - -/* - * Since the spinlocks are void on UP systems, we also need - * to have a special variant of interrupts-disabled spinlock - * macros which take this into account. - */ - -#define ASSERT_IRQ_SPINLOCK(expr, irq_lock) \ - ASSERT_SPINLOCK(expr, NULL) - -#define IRQ_SPINLOCK_INITIALIZE_NAME(lock_name, desc_name) \ - irq_spinlock_t lock_name = { \ - .guard = false, \ - .ipl = 0 \ - } - -#define IRQ_SPINLOCK_STATIC_INITIALIZE_NAME(lock_name, desc_name) \ - static irq_spinlock_t lock_name = { \ - .guard = false, \ - .ipl = 0 \ - } - -#endif /* CONFIG_SMP */ + static irq_spinlock_t lock_name = IRQ_SPINLOCK_INITIALIZER(desc_name) #define IRQ_SPINLOCK_INITIALIZE(lock_name) \ Index: kernel/generic/src/synch/irq_spinlock.c =================================================================== --- kernel/generic/src/synch/irq_spinlock.c (revision 95658c95a818a8da0be5aa39b51a70c6274f733a) +++ kernel/generic/src/synch/irq_spinlock.c (revision f43d8cef17ca84bb86ea598fe7053f90fc5d9fa0) @@ -36,4 +36,5 @@ */ +#include #include Index: kernel/generic/src/synch/spinlock.c =================================================================== --- kernel/generic/src/synch/spinlock.c (revision 95658c95a818a8da0be5aa39b51a70c6274f733a) +++ kernel/generic/src/synch/spinlock.c (revision f43d8cef17ca84bb86ea598fe7053f90fc5d9fa0) @@ -1,4 +1,5 @@ /* * Copyright (c) 2001-2004 Jakub Jermar + * Copyright (c) 2023 Jiří Zárevúcky * All rights reserved. * @@ -47,6 +48,4 @@ #include -#ifdef CONFIG_SMP - /** Initialize spinlock * @@ -56,28 +55,27 @@ void spinlock_initialize(spinlock_t *lock, const char *name) { +#ifdef CONFIG_SMP atomic_flag_clear_explicit(&lock->flag, memory_order_relaxed); #ifdef CONFIG_DEBUG_SPINLOCK lock->name = name; #endif +#endif } -#ifdef CONFIG_DEBUG_SPINLOCK - /** Lock spinlock - * - * Lock spinlock. - * This version has limitted ability to report - * possible occurence of deadlock. * * @param lock Pointer to spinlock_t structure. * */ -void spinlock_lock_debug(spinlock_t *lock) +void spinlock_lock(spinlock_t *lock) { + preemption_disable(); + +#ifdef CONFIG_SMP + bool deadlock_reported = false; size_t i = 0; - bool deadlock_reported = false; - preemption_disable(); while (atomic_flag_test_and_set_explicit(&lock->flag, memory_order_acquire)) { +#ifdef CONFIG_DEBUG_SPINLOCK /* * We need to be careful about particular locks @@ -111,28 +109,34 @@ deadlock_reported = true; } +#endif } + + /* Avoid compiler warning with debug disabled. */ + (void) i; if (deadlock_reported) printf("cpu%u: not deadlocked\n", CPU->id); + +#endif } /** Unlock spinlock * - * Unlock spinlock. - * * @param sl Pointer to spinlock_t structure. */ -void spinlock_unlock_debug(spinlock_t *lock) +void spinlock_unlock(spinlock_t *lock) { +#ifdef CONFIG_SMP +#ifdef CONFIG_DEBUG_SPINLOCK ASSERT_SPINLOCK(spinlock_locked(lock), lock); +#endif atomic_flag_clear_explicit(&lock->flag, memory_order_release); +#endif + preemption_enable(); } -#endif - -/** Lock spinlock conditionally - * +/** * Lock spinlock conditionally. If the spinlock is not available * at the moment, signal failure. @@ -140,5 +144,5 @@ * @param lock Pointer to spinlock_t structure. * - * @return Zero on failure, non-zero otherwise. + * @return true on success. * */ @@ -146,4 +150,6 @@ { preemption_disable(); + +#ifdef CONFIG_SMP bool ret = !atomic_flag_test_and_set_explicit(&lock->flag, memory_order_acquire); @@ -152,4 +158,7 @@ return ret; +#else + return true; +#endif } @@ -161,4 +170,5 @@ bool spinlock_locked(spinlock_t *lock) { +#ifdef CONFIG_SMP // NOTE: Atomic flag doesn't support simple atomic read (by design), // so instead we test_and_set and then clear if necessary. @@ -170,7 +180,8 @@ atomic_flag_clear_explicit(&lock->flag, memory_order_relaxed); return ret; +#else + return true; +#endif } - -#endif /** @} Index: kernel/generic/src/synch/waitq.c =================================================================== --- kernel/generic/src/synch/waitq.c (revision 95658c95a818a8da0be5aa39b51a70c6274f733a) +++ kernel/generic/src/synch/waitq.c (revision f43d8cef17ca84bb86ea598fe7053f90fc5d9fa0) @@ -48,4 +48,5 @@ #include #include +#include #include #include Index: kernel/generic/src/time/clock.c =================================================================== --- kernel/generic/src/time/clock.c (revision 95658c95a818a8da0be5aa39b51a70c6274f733a) +++ kernel/generic/src/time/clock.c (revision f43d8cef17ca84bb86ea598fe7053f90fc5d9fa0) @@ -59,4 +59,5 @@ #include #include +#include /* Pointer to variable with uptime */