kernel: add closing comments to config endifs

Add a closing comment to the endif with the configuration
information to which the endif belongs too.
To make the code more clearer if the configs need adaptions.

Signed-off-by: Simon Hein <Shein@baumer.com>

include/zephyr/kernel/internal/mm.h

@@ -39,7 +39,7 @@
 			 (CONFIG_SRAM_BASE_ADDRESS + CONFIG_SRAM_OFFSET))
 #else
 #define Z_MEM_VM_OFFSET	0
-#endif
+#endif /* CONFIG_MMU */
 
 #define Z_MEM_PHYS_ADDR(virt)	((virt) - Z_MEM_VM_OFFSET)
 #define Z_MEM_VIRT_ADDR(phys)	((phys) + Z_MEM_VM_OFFSET)
@@ -70,26 +70,26 @@ static inline uintptr_t z_mem_phys_addr(void *virt)
 	__ASSERT(
 #if CONFIG_KERNEL_VM_BASE != 0
 		 (addr >= CONFIG_KERNEL_VM_BASE) &&
-#endif
+#endif /* CONFIG_KERNEL_VM_BASE != 0 */
 #if (CONFIG_KERNEL_VM_BASE + CONFIG_KERNEL_VM_SIZE) != 0
 		 (addr < (CONFIG_KERNEL_VM_BASE +
 			  (CONFIG_KERNEL_VM_SIZE))),
 #else
 		 false,
-#endif
+#endif /* CONFIG_KERNEL_VM_BASE + CONFIG_KERNEL_VM_SIZE != 0 */
 		 "address %p not in permanent mappings", virt);
 #else
 	/* Should be identity-mapped */
 	__ASSERT(
 #if CONFIG_SRAM_BASE_ADDRESS != 0
 		 (addr >= CONFIG_SRAM_BASE_ADDRESS) &&
-#endif
+#endif /* CONFIG_SRAM_BASE_ADDRESS != 0 */
 #if (CONFIG_SRAM_BASE_ADDRESS + (CONFIG_SRAM_SIZE * 1024UL)) != 0
 		 (addr < (CONFIG_SRAM_BASE_ADDRESS +
 			  (CONFIG_SRAM_SIZE * 1024UL))),
 #else
 		 false,
-#endif
+#endif /* (CONFIG_SRAM_BASE_ADDRESS + (CONFIG_SRAM_SIZE * 1024UL)) != 0 */
 		 "physical address 0x%lx not in RAM",
 		 (unsigned long)addr);
 #endif /* CONFIG_MMU */
@@ -111,15 +111,15 @@ static inline void *z_mem_virt_addr(uintptr_t phys)
 	__ASSERT(
 #if CONFIG_SRAM_BASE_ADDRESS != 0
 		 (phys >= CONFIG_SRAM_BASE_ADDRESS) &&
-#endif
+#endif /* CONFIG_SRAM_BASE_ADDRESS != 0 */
 #if (CONFIG_SRAM_BASE_ADDRESS + (CONFIG_SRAM_SIZE * 1024UL)) != 0
 		 (phys < (CONFIG_SRAM_BASE_ADDRESS +
 			  (CONFIG_SRAM_SIZE * 1024UL))),
 #else
 		 false,
-#endif
+#endif /* (CONFIG_SRAM_BASE_ADDRESS + (CONFIG_SRAM_SIZE * 1024UL)) != 0 */
 		 "physical address 0x%lx not in RAM", (unsigned long)phys);
-#endif
+#endif /* CONFIG_KERNEL_VM_USE_CUSTOM_MEM_RANGE_CHECK */
 
 	/* TODO add assertion that this page frame is pinned to boot mapping,
 	 * the above check won't be sufficient with demand paging

include/zephyr/kernel/internal/smp.h

@@ -8,4 +8,4 @@
 
 void z_sched_ipi(void);
 
-#endif
+#endif /* ZEPHYR_INCLUDE_KERNEL_INTERNAL_SMP_H_ */

include/zephyr/kernel/mm.h

@@ -11,7 +11,7 @@
 #include <zephyr/toolchain.h>
 #if defined(CONFIG_ARM_MMU) && defined(CONFIG_ARM64)
 #include <zephyr/arch/arm64/arm_mem.h>
-#endif
+#endif /* CONFIG_ARM_MMU && CONFIG_ARM64 */
 
 #include <zephyr/kernel/internal/mm.h>
 

include/zephyr/kernel/mm/demand_paging.h

@@ -47,7 +47,7 @@ struct k_mem_paging_stats_t {
 #if !defined(CONFIG_DEMAND_PAGING_ALLOW_IRQ) || defined(__DOXYGEN__)
 		/** Number of page faults while in ISR */
 		unsigned long			in_isr;
-#endif
+#endif /* !CONFIG_DEMAND_PAGING_ALLOW_IRQ */
 	} pagefaults;
 
 	struct {

include/zephyr/kernel/obj_core.h

@@ -76,7 +76,7 @@ struct k_obj_core;
 #else
 #define K_OBJ_CORE_INIT(objp, type)   do { } while (0)
 #define K_OBJ_CORE_LINK(objp)         do { } while (0)
-#endif
+#endif /* CONFIG_OBJ_CORE */
 
 /**
  * INTERNAL_HIDDEN @endcond
@@ -114,7 +114,7 @@ struct k_obj_type {
 #ifdef CONFIG_OBJ_CORE_STATS
 	/** Pointer to object core statistics descriptor */
 	struct k_obj_core_stats_desc *stats_desc;
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS */
 };
 
 /** Object core structure */
@@ -123,7 +123,7 @@ struct k_obj_core {
 	struct k_obj_type *type;   /**< Object type to which object belongs */
 #ifdef CONFIG_OBJ_CORE_STATS
 	void  *stats;              /**< Pointer to kernel object's stats */
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS */
 };
 
 /**
@@ -280,7 +280,7 @@ static inline void k_obj_core_stats_init(struct k_obj_core *obj_core,
 {
 	obj_core->stats = stats;
 }
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS */
 
 /**
  * @brief Register kernel object for gathering statistics

include/zephyr/kernel/stats.h

@@ -26,8 +26,8 @@ struct k_cycle_stats {
 	uint64_t  longest;      /**< \# of cycles in longest usage window */
 	uint32_t  num_windows;  /**< \# of usage windows */
 	/** @} */
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ANALYSIS */
 	bool      track_usage;  /**< true if gathering usage stats */
 };
 
-#endif
+#endif /* ZEPHYR_INCLUDE_KERNEL_STATS_H_ */

include/zephyr/kernel/thread.h

@@ -9,7 +9,7 @@
 
 #ifdef CONFIG_DEMAND_PAGING_THREAD_STATS
 #include <zephyr/kernel/mm/demand_paging.h>
-#endif
+#endif /* CONFIG_DEMAND_PAGING_THREAD_STATS */
 
 #include <zephyr/kernel/stats.h>
 #include <zephyr/arch/arch_interface.h>
@@ -38,7 +38,7 @@ struct __thread_entry {
 	void *parameter2;
 	void *parameter3;
 };
-#endif
+#endif /* CONFIG_THREAD_MONITOR */
 
 struct k_thread;
 
@@ -96,14 +96,14 @@ struct _thread_base {
 #else /* Little Endian */
 			int8_t prio;
 			uint8_t sched_locked;
-#endif
+#endif /* CONFIG_BIG_ENDIAN */
 		};
 		uint16_t preempt;
 	};
 
 #ifdef CONFIG_SCHED_DEADLINE
 	int prio_deadline;
-#endif
+#endif /* CONFIG_SCHED_DEADLINE */
 
 	uint32_t order_key;
 
@@ -117,7 +117,7 @@ struct _thread_base {
 	/* Recursive count of irq_lock() calls */
 	uint8_t global_lock_count;
 
-#endif
+#endif /* CONFIG_SMP */
 
 #ifdef CONFIG_SCHED_CPU_MASK
 	/* "May run on" bits for each CPU */
@@ -125,7 +125,7 @@ struct _thread_base {
 	uint8_t cpu_mask;
 #else
 	uint16_t cpu_mask;
-#endif
+#endif /* CONFIG_MP_MAX_NUM_CPUS */
 #endif /* CONFIG_SCHED_CPU_MASK */
 
 	/* data returned by APIs */
@@ -134,17 +134,17 @@ struct _thread_base {
 #ifdef CONFIG_SYS_CLOCK_EXISTS
 	/* this thread's entry in a timeout queue */
 	struct _timeout timeout;
-#endif
+#endif /* CONFIG_SYS_CLOCK_EXISTS */
 
 #ifdef CONFIG_TIMESLICE_PER_THREAD
 	int32_t slice_ticks;
 	k_thread_timeslice_fn_t slice_expired;
 	void *slice_data;
-#endif
+#endif /* CONFIG_TIMESLICE_PER_THREAD */
 
 #ifdef CONFIG_SCHED_THREAD_USAGE
 	struct k_cycle_stats  usage;   /* Track thread usage statistics */
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE */
 };
 
 typedef struct _thread_base _thread_base_t;
@@ -190,9 +190,9 @@ struct _mem_domain_info {
 struct _thread_userspace_local_data {
 #if defined(CONFIG_ERRNO) && !defined(CONFIG_ERRNO_IN_TLS) && !defined(CONFIG_LIBC_ERRNO)
 	int errno_var;
-#endif
+#endif /* CONFIG_ERRNO && !CONFIG_ERRNO_IN_TLS && !CONFIG_LIBC_ERRNO */
 };
-#endif
+#endif /* CONFIG_THREAD_USERSPACE_LOCAL_DATA */
 
 typedef struct k_thread_runtime_stats {
 #ifdef CONFIG_SCHED_THREAD_USAGE
@@ -203,7 +203,7 @@ typedef struct k_thread_runtime_stats {
 	 * as the total # of non-idle cycles. In the context of CPU statistics,
 	 * it refers to the sum of non-idle + idle cycles.
 	 */
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE */
 
 #ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS
 	/*
@@ -216,7 +216,7 @@ typedef struct k_thread_runtime_stats {
 	uint64_t current_cycles;      /* current # of non-idle cycles */
 	uint64_t peak_cycles;         /* peak # of non-idle cycles */
 	uint64_t average_cycles;      /* average # of non-idle cycles */
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ANALYSIS */
 
 #ifdef CONFIG_SCHED_THREAD_USAGE_ALL
 	/*
@@ -226,7 +226,7 @@ typedef struct k_thread_runtime_stats {
 	 */
 
 	uint64_t idle_cycles;
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ALL */
 
 #if defined(__cplusplus) && !defined(CONFIG_SCHED_THREAD_USAGE) &&                                 \
 	!defined(CONFIG_SCHED_THREAD_USAGE_ANALYSIS) && !defined(CONFIG_SCHED_THREAD_USAGE_ALL)
@@ -262,7 +262,7 @@ struct k_thread {
 
 #if defined(CONFIG_POLL)
 	struct z_poller poller;
-#endif
+#endif /* CONFIG_POLL */
 
 #if defined(CONFIG_EVENTS)
 	struct k_thread *next_event_link;
@@ -272,7 +272,7 @@ struct k_thread {
 
 	/** true if timeout should not wake the thread */
 	bool no_wake_on_timeout;
-#endif
+#endif /* CONFIG_EVENTS */
 
 #if defined(CONFIG_THREAD_MONITOR)
 	/** thread entry and parameters description */
@@ -280,28 +280,28 @@ struct k_thread {
 
 	/** next item in list of all threads */
 	struct k_thread *next_thread;
-#endif
+#endif /* CONFIG_THREAD_MONITOR */
 
 #if defined(CONFIG_THREAD_NAME)
 	/** Thread name */
 	char name[CONFIG_THREAD_MAX_NAME_LEN];
-#endif
+#endif /* CONFIG_THREAD_NAME */
 
 #ifdef CONFIG_THREAD_CUSTOM_DATA
 	/** crude thread-local storage */
 	void *custom_data;
-#endif
+#endif /* CONFIG_THREAD_CUSTOM_DATA */
 
 #ifdef CONFIG_THREAD_USERSPACE_LOCAL_DATA
 	struct _thread_userspace_local_data *userspace_local_data;
-#endif
+#endif /* CONFIG_THREAD_USERSPACE_LOCAL_DATA */
 
 #if defined(CONFIG_ERRNO) && !defined(CONFIG_ERRNO_IN_TLS) && !defined(CONFIG_LIBC_ERRNO)
 #ifndef CONFIG_USERSPACE
 	/** per-thread errno variable */
 	int errno_var;
-#endif
-#endif
+#endif /* CONFIG_USERSPACE */
+#endif /* CONFIG_ERRNO && !CONFIG_ERRNO_IN_TLS && !CONFIG_LIBC_ERRNO */
 
 #if defined(CONFIG_THREAD_STACK_INFO)
 	/** Stack Info */
@@ -328,7 +328,7 @@ struct k_thread {
 
 	/** Context handle returned via arch_switch() */
 	void *switch_handle;
-#endif
+#endif /* CONFIG_USE_SWITCH */
 	/** resource pool */
 	struct k_heap *resource_pool;
 
@@ -340,21 +340,21 @@ struct k_thread {
 #ifdef CONFIG_DEMAND_PAGING_THREAD_STATS
 	/** Paging statistics */
 	struct k_mem_paging_stats_t paging_stats;
-#endif
+#endif /* CONFIG_DEMAND_PAGING_THREAD_STATS */
 
 #ifdef CONFIG_PIPES
 	/** Pipe descriptor used with blocking k_pipe operations */
 	struct _pipe_desc pipe_desc;
-#endif
+#endif /* CONFIG_PIPES */
 
 #ifdef CONFIG_OBJ_CORE_THREAD
 	struct k_obj_core  obj_core;
-#endif
+#endif /* CONFIG_OBJ_CORE_THREAD */
 
 #ifdef CONFIG_SMP
 	/** threads waiting in k_thread_suspend() */
 	_wait_q_t  halt_queue;
-#endif
+#endif /* CONFIG_SMP */
 
 	/** arch-specifics: must always be at the end */
 	struct _thread_arch arch;
@@ -363,4 +363,4 @@ struct k_thread {
 typedef struct k_thread _thread_t;
 typedef struct k_thread *k_tid_t;
 
-#endif
+#endif /* ZEPHYR_INCLUDE_KERNEL_THREAD_H_ */

include/zephyr/kernel/thread_stack.h

@@ -92,7 +92,7 @@ static inline char *z_stack_ptr_align(char *ptr)
 #define K_KERNEL_STACK_RESERVED	((size_t)ARCH_KERNEL_STACK_RESERVED)
 #else
 #define K_KERNEL_STACK_RESERVED	((size_t)0)
-#endif
+#endif /* ARCH_KERNEL_STACK_RESERVED */
 
 #define Z_KERNEL_STACK_SIZE_ADJUST(size) (ROUND_UP(size, \
 						   ARCH_STACK_PTR_ALIGN) + \
@@ -102,7 +102,7 @@ static inline char *z_stack_ptr_align(char *ptr)
 #define Z_KERNEL_STACK_OBJ_ALIGN	ARCH_KERNEL_STACK_OBJ_ALIGN
 #else
 #define Z_KERNEL_STACK_OBJ_ALIGN	ARCH_STACK_PTR_ALIGN
-#endif
+#endif /* ARCH_KERNEL_STACK_OBJ_ALIGN */
 
 #define Z_KERNEL_STACK_LEN(size) \
 	ROUND_UP(Z_KERNEL_STACK_SIZE_ADJUST(size), Z_KERNEL_STACK_OBJ_ALIGN)
@@ -232,7 +232,7 @@ static inline char *z_stack_ptr_align(char *ptr)
 #else
 #define K_KERNEL_PINNED_STACK_DEFINE(sym, size) \
 	Z_KERNEL_STACK_DEFINE_IN(sym, size, __kstackmem)
-#endif
+#endif /* CONFIG_LINKER_USE_PINNED_SECTION */
 
 /**
  * @brief Define a toplevel array of kernel stack memory regions
@@ -265,7 +265,7 @@ static inline char *z_stack_ptr_align(char *ptr)
 #else
 #define K_KERNEL_PINNED_STACK_ARRAY_DEFINE(sym, nmemb, size) \
 	Z_KERNEL_STACK_ARRAY_DEFINE_IN(sym, nmemb, size, __kstackmem)
-#endif
+#endif /* CONFIG_LINKER_USE_PINNED_SECTION */
 
 /**
  * @brief Define an embedded stack memory region
@@ -320,7 +320,7 @@ static inline char *Z_KERNEL_STACK_BUFFER(k_thread_stack_t *sym)
 #define K_THREAD_STACK_RESERVED		((size_t)(ARCH_THREAD_STACK_RESERVED))
 #else
 #define K_THREAD_STACK_RESERVED		((size_t)0U)
-#endif
+#endif /* ARCH_THREAD_STACK_RESERVED */
 
 /**
  * @brief Properly align the lowest address of a stack object
@@ -553,7 +553,7 @@ static inline char *Z_KERNEL_STACK_BUFFER(k_thread_stack_t *sym)
 #else
 #define K_THREAD_PINNED_STACK_DEFINE(sym, size) \
 	K_THREAD_STACK_DEFINE(sym, size)
-#endif
+#endif /* CONFIG_LINKER_USE_PINNED_SECTION */
 
 /**
  * @brief Calculate size of stacks to be allocated in a stack array
@@ -611,7 +611,7 @@ static inline char *Z_KERNEL_STACK_BUFFER(k_thread_stack_t *sym)
 #else
 #define K_THREAD_PINNED_STACK_ARRAY_DEFINE(sym, nmemb, size) \
 	K_THREAD_STACK_ARRAY_DEFINE(sym, nmemb, size)
-#endif
+#endif /* CONFIG_LINKER_USE_PINNED_SECTION */
 
 /**
  * @brief Define an embedded stack memory region

kernel/atomic_c.c

@@ -56,7 +56,7 @@ static struct k_spinlock lock;
 #else
 #define ATOMIC_SYSCALL_HANDLER_TARGET(name)
 #define ATOMIC_SYSCALL_HANDLER_TARGET_VALUE(name)
-#endif
+#endif /* CONFIG_USERSPACE */
 
 /**
  *
@@ -411,4 +411,4 @@ ATOMIC_SYSCALL_HANDLER_TARGET_VALUE(atomic_nand);
 #include <syscalls/atomic_xor_mrsh.c>
 #include <syscalls/atomic_and_mrsh.c>
 #include <syscalls/atomic_nand_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */

kernel/banner.c

@@ -14,15 +14,15 @@
 #define BANNER_POSTFIX " (delayed boot " DELAY_STR "ms)"
 #else
 #define BANNER_POSTFIX ""
-#endif
+#endif /* defined(CONFIG_BOOT_DELAY) && (CONFIG_BOOT_DELAY > 0) */
 
 #ifndef BANNER_VERSION
 #ifdef BUILD_VERSION
 #define BANNER_VERSION STRINGIFY(BUILD_VERSION)
 #else
 #define BANNER_VERSION KERNEL_VERSION_STRING
-#endif
-#endif
+#endif /* BUILD_VERSION */
+#endif /* !BANNER_VERSION */
 
 void boot_banner(void)
 {

kernel/condvar.c

@@ -14,7 +14,7 @@
 
 #ifdef CONFIG_OBJ_CORE_CONDVAR
 static struct k_obj_type obj_type_condvar;
-#endif
+#endif /* CONFIG_OBJ_CORE_CONDVAR */
 
 static struct k_spinlock lock;
 
@@ -25,7 +25,7 @@ int z_impl_k_condvar_init(struct k_condvar *condvar)
 
 #ifdef CONFIG_OBJ_CORE_CONDVAR
 	k_obj_core_init_and_link(K_OBJ_CORE(condvar), &obj_type_condvar);
-#endif
+#endif /* CONFIG_OBJ_CORE_CONDVAR */
 
 	SYS_PORT_TRACING_OBJ_INIT(k_condvar, condvar, 0);
 
@@ -39,7 +39,7 @@ int z_vrfy_k_condvar_init(struct k_condvar *condvar)
 	return z_impl_k_condvar_init(condvar);
 }
 #include <syscalls/k_condvar_init_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int z_impl_k_condvar_signal(struct k_condvar *condvar)
 {
@@ -71,7 +71,7 @@ int z_vrfy_k_condvar_signal(struct k_condvar *condvar)
 	return z_impl_k_condvar_signal(condvar);
 }
 #include <syscalls/k_condvar_signal_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int z_impl_k_condvar_broadcast(struct k_condvar *condvar)
 {
@@ -104,7 +104,7 @@ int z_vrfy_k_condvar_broadcast(struct k_condvar *condvar)
 	return z_impl_k_condvar_broadcast(condvar);
 }
 #include <syscalls/k_condvar_broadcast_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int z_impl_k_condvar_wait(struct k_condvar *condvar, struct k_mutex *mutex,
 			  k_timeout_t timeout)
@@ -133,7 +133,7 @@ int z_vrfy_k_condvar_wait(struct k_condvar *condvar, struct k_mutex *mutex,
 	return z_impl_k_condvar_wait(condvar, mutex, timeout);
 }
 #include <syscalls/k_condvar_wait_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 #ifdef CONFIG_OBJ_CORE_CONDVAR
 static int init_condvar_obj_core_list(void)
@@ -155,4 +155,4 @@ static int init_condvar_obj_core_list(void)
 
 SYS_INIT(init_condvar_obj_core_list, PRE_KERNEL_1,
 	 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
-#endif
+#endif /* CONFIG_OBJ_CORE_CONDVAR */

kernel/cpu_mask.c

@@ -13,7 +13,7 @@ extern struct k_spinlock _sched_spinlock;
 # ifdef CONFIG_SMP
 /* Right now we use a two byte for this mask */
 BUILD_ASSERT(CONFIG_MP_MAX_NUM_CPUS <= 16, "Too many CPUs for mask word");
-# endif
+# endif /* CONFIG_SMP */
 
 
 static int cpu_mask_mod(k_tid_t thread, uint32_t enable_mask, uint32_t disable_mask)
@@ -23,7 +23,7 @@ static int cpu_mask_mod(k_tid_t thread, uint32_t enable_mask, uint32_t disable_m
 #ifdef CONFIG_SCHED_CPU_MASK_PIN_ONLY
 	__ASSERT(z_is_thread_prevented_from_running(thread),
 		 "Running threads cannot change CPU pin");
-#endif
+#endif /* CONFIG_SCHED_CPU_MASK_PIN_ONLY */
 
 	K_SPINLOCK(&_sched_spinlock) {
 		if (z_is_thread_prevented_from_running(thread)) {
@@ -39,7 +39,7 @@ static int cpu_mask_mod(k_tid_t thread, uint32_t enable_mask, uint32_t disable_m
 
 		__ASSERT((m == 0) || ((m & (m - 1)) == 0),
 			 "Only one CPU allowed in mask when PIN_ONLY");
-#endif
+#endif /* defined(CONFIG_ASSERT) && defined(CONFIG_SCHED_CPU_MASK_PIN_ONLY) */
 
 	return ret;
 }

kernel/dynamic.c

@@ -20,7 +20,7 @@ LOG_MODULE_DECLARE(os, CONFIG_KERNEL_LOG_LEVEL);
 #define BA_SIZE CONFIG_DYNAMIC_THREAD_POOL_SIZE
 #else
 #define BA_SIZE 1
-#endif
+#endif /* CONFIG_DYNAMIC_THREAD_POOL_SIZE > 0 */
 
 struct dyn_cb_data {
 	k_tid_t tid;
@@ -71,7 +71,7 @@ static k_thread_stack_t *stack_alloc_dyn(size_t size, int flags)
 		 * enabled we can't proceed.
 		 */
 		return NULL;
-#endif
+#endif /* CONFIG_DYNAMIC_OBJECTS */
 	}
 
 	return z_thread_stack_alloc_dyn(Z_KERNEL_STACK_OBJ_ALIGN,
@@ -106,7 +106,7 @@ static inline k_thread_stack_t *z_vrfy_k_thread_stack_alloc(size_t size, int fla
 	return z_impl_k_thread_stack_alloc(size, flags);
 }
 #include <syscalls/k_thread_stack_alloc_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 static void dyn_cb(const struct k_thread *thread, void *user_data)
 {
@@ -154,7 +154,7 @@ int z_impl_k_thread_stack_free(k_thread_stack_t *stack)
 		}
 #else
 		k_free(stack);
-#endif
+#endif /* CONFIG_USERSPACE */
 	} else {
 		LOG_DBG("Invalid stack %p", stack);
 		return -EINVAL;
@@ -169,4 +169,4 @@ static inline int z_vrfy_k_thread_stack_free(k_thread_stack_t *stack)
 	return z_impl_k_thread_stack_free(stack);
 }
 #include <syscalls/k_thread_stack_free_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */

kernel/events.c

@@ -47,7 +47,7 @@ struct event_walk_data {
 
 #ifdef CONFIG_OBJ_CORE_EVENT
 static struct k_obj_type obj_type_event;
-#endif
+#endif /* CONFIG_OBJ_CORE_EVENT */
 
 void z_impl_k_event_init(struct k_event *event)
 {
@@ -62,7 +62,7 @@ void z_impl_k_event_init(struct k_event *event)
 
 #ifdef CONFIG_OBJ_CORE_EVENT
 	k_obj_core_init_and_link(K_OBJ_CORE(event), &obj_type_event);
-#endif
+#endif /* CONFIG_OBJ_CORE_EVENT */
 }
 
 #ifdef CONFIG_USERSPACE
@@ -72,7 +72,7 @@ void z_vrfy_k_event_init(struct k_event *event)
 	z_impl_k_event_init(event);
 }
 #include <syscalls/k_event_init_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 /**
  * @brief determine if desired set of events been satisfied
@@ -191,7 +191,7 @@ uint32_t z_vrfy_k_event_post(struct k_event *event, uint32_t events)
 	return z_impl_k_event_post(event, events);
 }
 #include <syscalls/k_event_post_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 uint32_t z_impl_k_event_set(struct k_event *event, uint32_t events)
 {
@@ -205,7 +205,7 @@ uint32_t z_vrfy_k_event_set(struct k_event *event, uint32_t events)
 	return z_impl_k_event_set(event, events);
 }
 #include <syscalls/k_event_set_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 uint32_t z_impl_k_event_set_masked(struct k_event *event, uint32_t events,
 			       uint32_t events_mask)
@@ -221,7 +221,7 @@ uint32_t z_vrfy_k_event_set_masked(struct k_event *event, uint32_t events,
 	return z_impl_k_event_set_masked(event, events, events_mask);
 }
 #include <syscalls/k_event_set_masked_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 uint32_t z_impl_k_event_clear(struct k_event *event, uint32_t events)
 {
@@ -235,7 +235,7 @@ uint32_t z_vrfy_k_event_clear(struct k_event *event, uint32_t events)
 	return z_impl_k_event_clear(event, events);
 }
 #include <syscalls/k_event_clear_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 static uint32_t k_event_wait_internal(struct k_event *event, uint32_t events,
 				      unsigned int options, k_timeout_t timeout)
@@ -321,7 +321,7 @@ uint32_t z_vrfy_k_event_wait(struct k_event *event, uint32_t events,
 	return z_impl_k_event_wait(event, events, reset, timeout);
 }
 #include <syscalls/k_event_wait_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 /**
  * Wait for all of the specified events
@@ -343,7 +343,7 @@ uint32_t z_vrfy_k_event_wait_all(struct k_event *event, uint32_t events,
 	return z_impl_k_event_wait_all(event, events, reset, timeout);
 }
 #include <syscalls/k_event_wait_all_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 #ifdef CONFIG_OBJ_CORE_EVENT
 static int init_event_obj_core_list(void)
@@ -364,4 +364,4 @@ static int init_event_obj_core_list(void)
 
 SYS_INIT(init_event_obj_core_list, PRE_KERNEL_1,
 	 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
-#endif
+#endif /* CONFIG_OBJ_CORE_EVENT */

kernel/fatal.c

@@ -108,7 +108,7 @@ void z_fatal_error(unsigned int reason, const z_arch_esf_t *esf)
 	if ((esf != NULL) && arch_is_in_nested_exception(esf)) {
 		LOG_ERR("Fault during interrupt handling\n");
 	}
-#endif
+#endif /* CONFIG_ARCH_HAS_NESTED_EXCEPTION_DETECTION */
 
 	LOG_ERR("Current thread: %p (%s)", thread,
 		thread_name_get(thread));

kernel/idle.c

@@ -30,7 +30,7 @@ void z_pm_save_idle_exit(void)
 #endif	/* CONFIG_PM */
 #ifdef CONFIG_SYS_CLOCK_EXISTS
 	sys_clock_idle_exit();
-#endif
+#endif /* CONFIG_SYS_CLOCK_EXISTS */
 }
 
 void idle(void *unused1, void *unused2, void *unused3)
@@ -87,7 +87,7 @@ void idle(void *unused1, void *unused2, void *unused3)
 		}
 #else
 		k_cpu_idle();
-#endif
+#endif /* CONFIG_PM */
 
 #if !defined(CONFIG_PREEMPT_ENABLED)
 # if !defined(CONFIG_USE_SWITCH) || defined(CONFIG_SPARC)
@@ -103,8 +103,8 @@ void idle(void *unused1, void *unused2, void *unused3)
 		if (_kernel.ready_q.cache != _current) {
 			z_swap_unlocked();
 		}
-# endif
-#endif
+# endif /* !defined(CONFIG_USE_SWITCH) || defined(CONFIG_SPARC) */
+#endif /* !defined(CONFIG_PREEMPT_ENABLED) */
 	}
 }
 

kernel/include/kernel_arch_interface.h

@@ -37,7 +37,7 @@ extern "C" {
  * @param usec_to_wait Wait period, in microseconds
  */
 void arch_busy_wait(uint32_t usec_to_wait);
-#endif
+#endif /* CONFIG_ARCH_HAS_CUSTOM_BUSY_WAIT */
 
 /** @} */
 
@@ -154,7 +154,7 @@ int arch_swap(unsigned int key);
  */
 static ALWAYS_INLINE void
 arch_thread_return_value_set(struct k_thread *thread, unsigned int value);
-#endif /* CONFIG_USE_SWITCH i*/
+#endif /* CONFIG_USE_SWITCH */
 
 #ifdef CONFIG_ARCH_HAS_CUSTOM_SWAP_TO_MAIN
 /**

kernel/include/kernel_internal.h

@@ -43,7 +43,7 @@ static inline void z_data_copy(void)
 {
 	/* Do nothing */
 }
-#endif
+#endif /* CONFIG_XIP */
 
 #ifdef CONFIG_LINKER_USE_BOOT_SECTION
 void z_bss_zero_boot(void);
@@ -52,7 +52,7 @@ static inline void z_bss_zero_boot(void)
 {
 	/* Do nothing */
 }
-#endif
+#endif /* CONFIG_LINKER_USE_BOOT_SECTION */
 
 #ifdef CONFIG_LINKER_USE_PINNED_SECTION
 void z_bss_zero_pinned(void);
@@ -61,7 +61,7 @@ static inline void z_bss_zero_pinned(void)
 {
 	/* Do nothing */
 }
-#endif
+#endif /* CONFIG_LINKER_USE_PINNED_SECTION */
 
 FUNC_NORETURN void z_cstart(void);
 
@@ -135,27 +135,27 @@ z_thread_return_value_set_with_data(struct k_thread *thread,
 extern void z_smp_init(void);
 #ifdef CONFIG_SYS_CLOCK_EXISTS
 extern void smp_timer_init(void);
-#endif
-#endif
+#endif /* CONFIG_SYS_CLOCK_EXISTS */
+#endif /* CONFIG_SMP */
 
 extern void z_early_rand_get(uint8_t *buf, size_t length);
 
 #if CONFIG_STACK_POINTER_RANDOM
 extern int z_stack_adjust_initialized;
-#endif
+#endif /* CONFIG_STACK_POINTER_RANDOM */
 
 extern struct k_thread z_main_thread;
 
 
 #ifdef CONFIG_MULTITHREADING
 extern struct k_thread z_idle_threads[CONFIG_MP_MAX_NUM_CPUS];
-#endif
+#endif /* CONFIG_MULTITHREADING */
 K_KERNEL_PINNED_STACK_ARRAY_DECLARE(z_interrupt_stacks, CONFIG_MP_MAX_NUM_CPUS,
 				    CONFIG_ISR_STACK_SIZE);
 
 #ifdef CONFIG_GEN_PRIV_STACKS
 extern uint8_t *z_priv_stack_find(k_thread_stack_t *stack);
-#endif
+#endif /* CONFIG_GEN_PRIV_STACKS */
 
 /* Calculate stack usage. */
 int z_stack_space_get(const uint8_t *stack_start, size_t size, size_t *unused_ptr);
@@ -189,7 +189,7 @@ struct gdb_ctx;
  * and synchronously communicate with gdb on host.
  */
 extern int z_gdb_main_loop(struct gdb_ctx *ctx);
-#endif
+#endif /* CONFIG_GDBSTUB */
 
 #ifdef CONFIG_INSTRUMENT_THREAD_SWITCHING
 void z_thread_mark_switched_in(void);
@@ -263,7 +263,7 @@ bool pm_system_suspend(int32_t ticks);
  */
 void pm_system_resume(void);
 
-#endif
+#endif /* CONFIG_PM */
 
 #ifdef CONFIG_DEMAND_PAGING_TIMING_HISTOGRAM
 /**
@@ -287,7 +287,7 @@ int z_thread_stats_query(struct k_obj_core *obj_core, void *stats);
 int z_thread_stats_reset(struct k_obj_core *obj_core);
 int z_thread_stats_disable(struct k_obj_core *obj_core);
 int z_thread_stats_enable(struct k_obj_core *obj_core);
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_THREAD */
 
 #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
 int z_cpu_stats_raw(struct k_obj_core *obj_core, void *stats);
@@ -295,7 +295,7 @@ int z_cpu_stats_query(struct k_obj_core *obj_core, void *stats);
 
 int z_kernel_stats_raw(struct k_obj_core *obj_core, void *stats);
 int z_kernel_stats_query(struct k_obj_core *obj_core, void *stats);
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_SYSTEM */
 
 #ifdef __cplusplus
 }

kernel/include/kernel_offsets.h

@@ -34,23 +34,23 @@ GEN_OFFSET_SYM(_kernel_t, cpus);
 
 #if defined(CONFIG_FPU_SHARING)
 GEN_OFFSET_SYM(_cpu_t, fp_ctx);
-#endif
+#endif /* CONFIG_FPU_SHARING */
 
 #ifdef CONFIG_PM
 GEN_OFFSET_SYM(_kernel_t, idle);
-#endif
+#endif /* CONFIG_PM */
 
 #ifndef CONFIG_SCHED_CPU_MASK_PIN_ONLY
 GEN_OFFSET_SYM(_kernel_t, ready_q);
-#endif
+#endif /* CONFIG_SCHED_CPU_MASK_PIN_ONLY */
 
 #ifndef CONFIG_SMP
 GEN_OFFSET_SYM(_ready_q_t, cache);
-#endif
+#endif /* CONFIG_SMP */
 
 #ifdef CONFIG_FPU_SHARING
 GEN_OFFSET_SYM(_kernel_t, current_fp);
-#endif
+#endif /* CONFIG_FPU_SHARING */
 
 GEN_OFFSET_SYM(_thread_base_t, user_options);
 
@@ -60,15 +60,15 @@ GEN_OFFSET_SYM(_thread_t, arch);
 
 #ifdef CONFIG_USE_SWITCH
 GEN_OFFSET_SYM(_thread_t, switch_handle);
-#endif
+#endif /* CONFIG_USE_SWITCH */
 
 #ifdef CONFIG_THREAD_STACK_INFO
 GEN_OFFSET_SYM(_thread_t, stack_info);
-#endif
+#endif /* CONFIG_THREAD_STACK_INFO */
 
 #ifdef CONFIG_THREAD_LOCAL_STORAGE
 GEN_OFFSET_SYM(_thread_t, tls);
-#endif
+#endif /* CONFIG_THREAD_LOCAL_STORAGE */
 
 GEN_ABSOLUTE_SYM(__z_interrupt_stack_SIZEOF, sizeof(z_interrupt_stacks[0]));
 
@@ -76,12 +76,12 @@ GEN_ABSOLUTE_SYM(__z_interrupt_stack_SIZEOF, sizeof(z_interrupt_stacks[0]));
 #ifdef CONFIG_DEVICE_DEPS
 GEN_ABSOLUTE_SYM(_DEVICE_STRUCT_HANDLES_OFFSET,
 		 offsetof(struct device, deps));
-#endif
+#endif /* CONFIG_DEVICE_DEPS */
 
 #ifdef CONFIG_PM_DEVICE
 GEN_ABSOLUTE_SYM(_DEVICE_STRUCT_PM_OFFSET,
 		 offsetof(struct device, pm));
-#endif
+#endif /* CONFIG_PM_DEVICE */
 
 /* member offsets in the pm_device structure. Used in image post-processing */
 

kernel/include/ksched.h

@@ -34,7 +34,7 @@ BUILD_ASSERT(K_LOWEST_APPLICATION_THREAD_PRIO
 #else
 #define Z_VALID_PRIO(prio, entry_point) ((prio) == -1)
 #define Z_ASSERT_VALID_PRIO(prio, entry_point) __ASSERT((prio) == -1, "")
-#endif
+#endif /* CONFIG_MULTITHREADING */
 
 void z_sched_init(void);
 void z_move_thread_to_end_of_prio_q(struct k_thread *thread);
@@ -80,7 +80,7 @@ static inline bool z_is_idle_thread_object(struct k_thread *thread)
 	return thread->base.is_idle;
 #else
 	return thread == &z_idle_threads[0];
-#endif
+#endif /* CONFIG_SMP */
 #else
 	return false;
 #endif /* CONFIG_MULTITHREADING */
@@ -417,7 +417,7 @@ static inline void z_sched_usage_switch(struct k_thread *thread)
 #ifdef CONFIG_SCHED_THREAD_USAGE
 	z_sched_usage_stop();
 	z_sched_usage_start(thread);
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE */
 }
 
 #endif /* ZEPHYR_KERNEL_INCLUDE_KSCHED_H_ */

kernel/include/kswap.h

@@ -15,7 +15,7 @@
 extern void z_check_stack_sentinel(void);
 #else
 #define z_check_stack_sentinel() /**/
-#endif
+#endif /* CONFIG_STACK_SENTINEL */
 
 extern struct k_spinlock _sched_spinlock;
 
@@ -63,7 +63,7 @@ static inline void z_sched_switch_spin(struct k_thread *thread)
 	 * non-null.
 	 */
 	barrier_dmem_fence_full();
-#endif
+#endif /* CONFIG_SMP */
 }
 
 /* New style context switching.  arch_switch() is a lower level
@@ -99,8 +99,8 @@ static ALWAYS_INLINE unsigned int do_swap(unsigned int key,
 	__ASSERT(arch_irq_unlocked(key) ||
 		 _current->base.thread_state & (_THREAD_DUMMY | _THREAD_DEAD),
 		 "Context switching while holding lock!");
-# endif
-#endif
+# endif /* CONFIG_ARM64 */
+#endif /* CONFIG_SPIN_VALIDATE */
 
 	old_thread = _current;
 
@@ -131,18 +131,18 @@ static ALWAYS_INLINE unsigned int do_swap(unsigned int key,
 		if (!is_spinlock) {
 			z_smp_release_global_lock(new_thread);
 		}
-#endif
+#endif /* CONFIG_SMP */
 		z_thread_mark_switched_out();
 		z_sched_switch_spin(new_thread);
 		_current_cpu->current = new_thread;
 
 #ifdef CONFIG_TIMESLICING
 		z_reset_time_slice(new_thread);
-#endif
+#endif /* CONFIG_TIMESLICING */
 
 #ifdef CONFIG_SPIN_VALIDATE
 		z_spin_lock_set_owner(&_sched_spinlock);
-#endif
+#endif /* CONFIG_SPIN_VALIDATE */
 
 		arch_cohere_stacks(old_thread, NULL, new_thread);
 
@@ -152,7 +152,7 @@ static ALWAYS_INLINE unsigned int do_swap(unsigned int key,
 		 * time.  See z_sched_switch_spin().
 		 */
 		z_requeue_current(old_thread);
-#endif
+#endif /* CONFIG_SMP */
 		void *newsh = new_thread->switch_handle;
 
 		if (IS_ENABLED(CONFIG_SMP)) {
@@ -241,24 +241,24 @@ static inline void z_dummy_thread_init(struct k_thread *dummy_thread)
 	dummy_thread->base.thread_state = _THREAD_DUMMY;
 #ifdef CONFIG_SCHED_CPU_MASK
 	dummy_thread->base.cpu_mask = -1;
-#endif
+#endif /* CONFIG_SCHED_CPU_MASK */
 	dummy_thread->base.user_options = K_ESSENTIAL;
 #ifdef CONFIG_THREAD_STACK_INFO
 	dummy_thread->stack_info.start = 0U;
 	dummy_thread->stack_info.size = 0U;
-#endif
+#endif /* CONFIG_THREAD_STACK_INFO */
 #ifdef CONFIG_USERSPACE
 	dummy_thread->mem_domain_info.mem_domain = &k_mem_domain_default;
-#endif
+#endif /* CONFIG_USERSPACE */
 #if (K_HEAP_MEM_POOL_SIZE > 0)
 	k_thread_system_pool_assign(dummy_thread);
 #else
 	dummy_thread->resource_pool = NULL;
-#endif
+#endif /* K_HEAP_MEM_POOL_SIZE */
 
 #ifdef CONFIG_TIMESLICE_PER_THREAD
 	dummy_thread->base.slice_ticks = 0;
-#endif
+#endif /* CONFIG_TIMESLICE_PER_THREAD */
 
 	_current_cpu->current = dummy_thread;
 }

kernel/include/kthread.h

@@ -17,7 +17,7 @@
  * thread->next_thread (until NULL)
  */
 extern struct k_spinlock z_thread_monitor_lock;
-#endif
+#endif /* CONFIG_THREAD_MONITOR */
 
 /* clean up when a thread is aborted */
 
@@ -42,8 +42,8 @@ static inline void thread_schedule_new(struct k_thread *thread, k_timeout_t dela
 #else
 	ARG_UNUSED(delay);
 	k_thread_start(thread);
-#endif
+#endif /* CONFIG_SYS_CLOCK_EXISTS */
 }
-#endif
+#endif /* CONFIG_MULTITHREADING */
 
 #endif /* ZEPHYR_KERNEL_INCLUDE_THREAD_H_ */

kernel/include/mmu.h

@@ -54,7 +54,7 @@
 #define Z_FREE_VM_START	Z_BOOT_PHYS_TO_VIRT(Z_PHYS_RAM_END)
 #else
 #define Z_FREE_VM_START	Z_KERNEL_VIRT_END
-#endif
+#endif /* CONFIG_ARCH_MAPS_ALL_RAM */
 
 /*
  * Macros and data structures for physical page frame accounting,
@@ -121,7 +121,7 @@ struct z_page_frame {
 } __aligned(4);
 #else
 } __packed;
-#endif
+#endif /* CONFIG_XTENSA */
 
 static inline bool z_page_frame_is_pinned(struct z_page_frame *pf)
 {
@@ -237,7 +237,7 @@ void z_page_frames_dump(void);
 				     CONFIG_MMU_PAGE_SIZE))
 #else
 #define Z_VM_RESERVED	0
-#endif
+#endif /* CONFIG_DEMAND_PAGING */
 
 #ifdef CONFIG_DEMAND_PAGING
 /*

kernel/include/priority_q.h

@@ -16,7 +16,7 @@
 #  define _priq_run_best	_priq_dumb_mask_best
 # else
 #  define _priq_run_best	z_priq_dumb_best
-# endif
+# endif /* CONFIG_SCHED_CPU_MASK */
 /* Scalable Scheduling */
 #elif defined(CONFIG_SCHED_SCALABLE)
 #define _priq_run_add		z_priq_rb_add

kernel/include/timeout_q.h

@@ -73,7 +73,7 @@ static inline void z_add_thread_timeout(struct k_thread *thread, k_timeout_t tic
 	ARG_UNUSED(ticks);
 }
 
-#endif
+#endif /* CONFIG_SYS_CLOCK_EXISTS */
 
 #ifdef __cplusplus
 }

kernel/init.c

@@ -85,7 +85,7 @@ static void z_init_static_threads(void)
 					      pos->thread);
 		}
 	}
-#endif
+#endif /* CONFIG_USERSPACE */
 
 	/*
 	 * Non-legacy static threads may be started immediately or
@@ -128,12 +128,12 @@ enum init_level {
 	INIT_LEVEL_APPLICATION,
 #ifdef CONFIG_SMP
 	INIT_LEVEL_SMP,
-#endif
+#endif /* CONFIG_SMP */
 };
 
 #ifdef CONFIG_SMP
 extern const struct init_entry __init_SMP_start[];
-#endif
+#endif /* CONFIG_SMP */
 
 /*
  * storage space for the interrupt stack
@@ -173,8 +173,8 @@ static struct k_obj_core_stats_desc  kernel_stats_desc = {
 	.disable = NULL,
 	.enable  = NULL,
 };
-#endif
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_SYSTEM */
+#endif /* CONFIG_OBJ_CORE_SYSTEM */
 
 /* LCOV_EXCL_START
  *
@@ -245,7 +245,7 @@ void z_bss_zero(void)
 #ifdef CONFIG_COVERAGE_GCOV
 	z_early_memset(&__gcov_bss_start, 0,
 		       ((uintptr_t) &__gcov_bss_end - (uintptr_t) &__gcov_bss_start));
-#endif
+#endif /* CONFIG_COVERAGE_GCOV */
 }
 
 #ifdef CONFIG_LINKER_USE_BOOT_SECTION
@@ -279,7 +279,7 @@ void z_bss_zero_boot(void)
 __boot_func
 #else
 __pinned_func
-#endif
+#endif /* CONFIG_LINKER_USE_BOOT_SECTION */
 void z_bss_zero_pinned(void)
 {
 	z_early_memset(&lnkr_pinned_bss_start, 0,
@@ -293,7 +293,7 @@ void z_bss_zero_pinned(void)
 extern __thread volatile uintptr_t __stack_chk_guard;
 #else
 extern volatile uintptr_t __stack_chk_guard;
-#endif
+#endif /* CONFIG_STACK_CANARIES_TLS */
 #endif /* CONFIG_STACK_CANARIES */
 
 /* LCOV_EXCL_STOP */
@@ -322,7 +322,7 @@ static void z_sys_init_run_level(enum init_level level)
 		__init_APPLICATION_start,
 #ifdef CONFIG_SMP
 		__init_SMP_start,
-#endif
+#endif /* CONFIG_SMP */
 		/* End marker */
 		__init_end,
 	};
@@ -391,13 +391,13 @@ static void bg_thread_main(void *unused1, void *unused2, void *unused3)
 	z_sys_init_run_level(INIT_LEVEL_POST_KERNEL);
 #if CONFIG_STACK_POINTER_RANDOM
 	z_stack_adjust_initialized = 1;
-#endif
+#endif /* CONFIG_STACK_POINTER_RANDOM */
 	boot_banner();
 
 #if defined(CONFIG_CPP)
 	void z_cpp_init_static(void);
 	z_cpp_init_static();
-#endif
+#endif /* CONFIG_CPP */
 
 	/* Final init level before app starts */
 	z_sys_init_run_level(INIT_LEVEL_APPLICATION);
@@ -406,14 +406,14 @@ static void bg_thread_main(void *unused1, void *unused2, void *unused3)
 
 #ifdef CONFIG_KERNEL_COHERENCE
 	__ASSERT_NO_MSG(arch_mem_coherent(&_kernel));
-#endif
+#endif /* CONFIG_KERNEL_COHERENCE */
 
 #ifdef CONFIG_SMP
 	if (!IS_ENABLED(CONFIG_SMP_BOOT_DELAY)) {
 		z_smp_init();
 	}
 	z_sys_init_run_level(INIT_LEVEL_SMP);
-#endif
+#endif /* CONFIG_SMP */
 
 #ifdef CONFIG_MMU
 	z_mem_manage_boot_finish();
@@ -429,7 +429,7 @@ static void bg_thread_main(void *unused1, void *unused2, void *unused3)
 #ifdef CONFIG_COVERAGE_DUMP
 	/* Dump coverage data once the main() has exited. */
 	gcov_coverage_dump();
-#endif
+#endif /* CONFIG_COVERAGE_DUMP */
 } /* LCOV_EXCL_LINE ... because we just dumped final coverage data */
 
 #if defined(CONFIG_MULTITHREADING)
@@ -446,7 +446,7 @@ static void init_idle_thread(int i)
 	snprintk(tname, 8, "idle %02d", i);
 #else
 	char *tname = "idle";
-#endif
+#endif /* CONFIG_MP_MAX_NUM_CPUS */
 
 #else
 	char *tname = NULL;
@@ -460,7 +460,7 @@ static void init_idle_thread(int i)
 
 #ifdef CONFIG_SMP
 	thread->base.is_idle = 1U;
-#endif
+#endif /* CONFIG_SMP */
 }
 
 void z_init_cpu(int id)
@@ -524,7 +524,7 @@ static char *prepare_multithreading(void)
 	 *   to work as intended
 	 */
 	_kernel.ready_q.cache = &z_main_thread;
-#endif
+#endif /* CONFIG_SMP */
 	stack_ptr = z_setup_new_thread(&z_main_thread, z_main_stack,
 				       CONFIG_MAIN_STACK_SIZE, bg_thread_main,
 				       NULL, NULL, NULL,
@@ -551,7 +551,7 @@ static FUNC_NORETURN void switch_to_main_thread(char *stack_ptr)
 	 * will never be rescheduled in.
 	 */
 	z_swap_unlocked();
-#endif
+#endif /* CONFIG_ARCH_HAS_CUSTOM_SWAP_TO_MAIN */
 	CODE_UNREACHABLE; /* LCOV_EXCL_LINE */
 }
 #endif /* CONFIG_MULTITHREADING */
@@ -573,7 +573,7 @@ void __weak z_early_rand_get(uint8_t *buf, size_t length)
 			buf += rc;
 		}
 	}
-#endif
+#endif /* CONFIG_ENTROPY_HAS_DRIVER */
 
 	while (length > 0) {
 		uint32_t val;
@@ -621,7 +621,7 @@ FUNC_NORETURN void z_cstart(void)
 	struct k_thread dummy_thread;
 
 	z_dummy_thread_init(&dummy_thread);
-#endif
+#endif /* CONFIG_MULTITHREADING */
 	/* do any necessary initialization of static devices */
 	z_device_state_init();
 
@@ -640,7 +640,7 @@ FUNC_NORETURN void z_cstart(void)
 #ifdef CONFIG_TIMING_FUNCTIONS_NEED_AT_BOOT
 	timing_init();
 	timing_start();
-#endif
+#endif /* CONFIG_TIMING_FUNCTIONS_NEED_AT_BOOT */
 
 #ifdef CONFIG_MULTITHREADING
 	switch_to_main_thread(prepare_multithreading());
@@ -661,7 +661,7 @@ FUNC_NORETURN void z_cstart(void)
 	while (true) {
 	}
 	/* LCOV_EXCL_STOP */
-#endif
+#endif /* ARCH_SWITCH_TO_MAIN_NO_MULTITHREADING */
 #endif /* CONFIG_MULTITHREADING */
 
 	/*
@@ -683,7 +683,7 @@ static int init_cpu_obj_core_list(void)
 
 #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
 	k_obj_type_stats_init(&obj_type_cpu, &cpu_stats_desc);
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_SYSTEM */
 
 	return 0;
 }
@@ -697,13 +697,13 @@ static int init_kernel_obj_core_list(void)
 
 #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
 	k_obj_type_stats_init(&obj_type_kernel, &kernel_stats_desc);
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_SYSTEM */
 
 	k_obj_core_init_and_link(K_OBJ_CORE(&_kernel), &obj_type_kernel);
 #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
 	k_obj_core_stats_register(K_OBJ_CORE(&_kernel), _kernel.usage,
 				  sizeof(_kernel.usage));
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_SYSTEM */
 
 	return 0;
 }
@@ -713,4 +713,4 @@ SYS_INIT(init_cpu_obj_core_list, PRE_KERNEL_1,
 
 SYS_INIT(init_kernel_obj_core_list, PRE_KERNEL_1,
 	 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
-#endif
+#endif /* CONFIG_OBJ_CORE_SYSTEM */

kernel/irq_offload.c

@@ -19,5 +19,5 @@ void irq_offload(irq_offload_routine_t routine, const void *parameter)
 	k_sem_take(&offload_sem, K_FOREVER);
 	arch_irq_offload(routine, parameter);
 	k_sem_give(&offload_sem);
-#endif
+#endif /* CONFIG_IRQ_OFFLOAD_NESTED */
 }

kernel/mailbox.c

@@ -22,7 +22,7 @@
 
 #ifdef CONFIG_OBJ_CORE_MAILBOX
 static struct k_obj_type  obj_type_mailbox;
-#endif
+#endif /* CONFIG_OBJ_CORE_MAILBOX */
 
 #if (CONFIG_NUM_MBOX_ASYNC_MSGS > 0)
 
@@ -97,7 +97,7 @@ void k_mbox_init(struct k_mbox *mbox)
 
 #ifdef CONFIG_OBJ_CORE_MAILBOX
 	k_obj_core_init_and_link(K_OBJ_CORE(mbox), &obj_type_mailbox);
-#endif
+#endif /* CONFIG_OBJ_CORE_MAILBOX */
 
 	SYS_PORT_TRACING_OBJ_INIT(k_mbox, mbox);
 }
@@ -189,7 +189,7 @@ static void mbox_message_dispose(struct k_mbox_msg *rx_msg)
 		}
 		return;
 	}
-#endif
+#endif /* CONFIG_NUM_MBOX_ASYNC_MSGS */
 
 	/* synchronous send: wake up sending thread */
 	arch_thread_return_value_set(sending_thread, 0);
@@ -256,7 +256,7 @@ static int mbox_message_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
 				z_reschedule(&mbox->lock, key);
 				return 0;
 			}
-#endif
+#endif /* CONFIG_NUM_MBOX_ASYNC_MSGS */
 			SYS_PORT_TRACING_OBJ_FUNC_BLOCKING(k_mbox, message_put, mbox, timeout);
 
 			/*
@@ -286,7 +286,7 @@ static int mbox_message_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
 		k_spin_unlock(&mbox->lock, key);
 		return 0;
 	}
-#endif
+#endif /* CONFIG_NUM_MBOX_ASYNC_MSGS */
 	SYS_PORT_TRACING_OBJ_FUNC_BLOCKING(k_mbox, message_put, mbox, timeout);
 
 	/* synchronous send: sender waits on tx queue for receiver or timeout */
@@ -335,7 +335,7 @@ void k_mbox_async_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
 	(void)mbox_message_put(mbox, &async->tx_msg, K_FOREVER);
 	SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_mbox, async_put, mbox, sem);
 }
-#endif
+#endif /* CONFIG_NUM_MBOX_ASYNC_MSGS */
 
 void k_mbox_data_get(struct k_mbox_msg *rx_msg, void *buffer)
 {
@@ -463,4 +463,4 @@ static int init_mailbox_obj_core_list(void)
 
 SYS_INIT(init_mailbox_obj_core_list, PRE_KERNEL_1,
 	 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
-#endif
+#endif /* CONFIG_OBJ_CORE_MAILBOX */

kernel/mem_domain.c

@@ -43,7 +43,7 @@ static bool check_add_partition(struct k_mem_domain *domain,
 			part->start);
 		return false;
 	}
-#endif
+#endif /* CONFIG_EXECUTE_XOR_WRITE */
 
 	if (part->size == 0U) {
 		LOG_ERR("zero sized partition at %p with base 0x%lx",
@@ -124,7 +124,7 @@ int k_mem_domain_init(struct k_mem_domain *domain, uint8_t num_parts,
 		ret = -ENOMEM;
 		goto unlock_out;
 	}
-#endif
+#endif /* CONFIG_ARCH_MEM_DOMAIN_DATA */
 	if (num_parts != 0U) {
 		uint32_t i;
 
@@ -145,7 +145,7 @@ int k_mem_domain_init(struct k_mem_domain *domain, uint8_t num_parts,
 			CHECKIF(ret2 != 0) {
 				ret = ret2;
 			}
-#endif
+#endif /* CONFIG_ARCH_MEM_DOMAIN_SYNCHRONOUS_API */
 		}
 	}
 
@@ -200,7 +200,7 @@ int k_mem_domain_add_partition(struct k_mem_domain *domain,
 
 #ifdef CONFIG_ARCH_MEM_DOMAIN_SYNCHRONOUS_API
 	ret = arch_mem_domain_partition_add(domain, p_idx);
-#endif
+#endif /* CONFIG_ARCH_MEM_DOMAIN_SYNCHRONOUS_API */
 
 unlock_out:
 	k_spin_unlock(&z_mem_domain_lock, key);
@@ -242,7 +242,7 @@ int k_mem_domain_remove_partition(struct k_mem_domain *domain,
 
 #ifdef CONFIG_ARCH_MEM_DOMAIN_SYNCHRONOUS_API
 	ret = arch_mem_domain_partition_remove(domain, p_idx);
-#endif
+#endif /* CONFIG_ARCH_MEM_DOMAIN_SYNCHRONOUS_API */
 
 	/* A zero-sized partition denotes it's a free partition */
 	domain->partitions[p_idx].size = 0U;
@@ -271,7 +271,7 @@ static int add_thread_locked(struct k_mem_domain *domain,
 
 #ifdef CONFIG_ARCH_MEM_DOMAIN_SYNCHRONOUS_API
 	ret = arch_mem_domain_thread_add(thread);
-#endif
+#endif /* CONFIG_ARCH_MEM_DOMAIN_SYNCHRONOUS_API */
 
 	return ret;
 }
@@ -287,7 +287,7 @@ static int remove_thread_locked(struct k_thread *thread)
 
 #ifdef CONFIG_ARCH_MEM_DOMAIN_SYNCHRONOUS_API
 	ret = arch_mem_domain_thread_remove(thread);
-#endif
+#endif /* CONFIG_ARCH_MEM_DOMAIN_SYNCHRONOUS_API */
 
 	return ret;
 }

kernel/mem_slab.c

@@ -55,7 +55,7 @@ static int k_mem_slab_stats_query(struct k_obj_core *obj_core, void *stats)
 	ptr->max_allocated_bytes = slab->info.max_used * slab->info.block_size;
 #else
 	ptr->max_allocated_bytes = 0;
-#endif
+#endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */
 	k_spin_unlock(&slab->lock, key);
 
 	return 0;
@@ -73,7 +73,7 @@ static int k_mem_slab_stats_reset(struct k_obj_core *obj_core)
 
 #ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
 	slab->info.max_used = slab->info.num_used;
-#endif
+#endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */
 
 	k_spin_unlock(&slab->lock, key);
 
@@ -89,8 +89,8 @@ static struct k_obj_core_stats_desc mem_slab_stats_desc = {
 	.disable = NULL,
 	.enable = NULL,
 };
-#endif
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_MEM_SLAB */
+#endif /* CONFIG_OBJ_CORE_MEM_SLAB */
 
 /**
  * @brief Initialize kernel memory slab subsystem.
@@ -141,8 +141,8 @@ static int init_mem_slab_obj_core_list(void)
 			offsetof(struct k_mem_slab, obj_core));
 #ifdef CONFIG_OBJ_CORE_STATS_MEM_SLAB
 	k_obj_type_stats_init(&obj_type_mem_slab, &mem_slab_stats_desc);
-#endif
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_MEM_SLAB */
+#endif /* CONFIG_OBJ_CORE_MEM_SLAB */
 
 	/* Initialize statically defined mem_slabs */
 
@@ -158,8 +158,8 @@ static int init_mem_slab_obj_core_list(void)
 #ifdef CONFIG_OBJ_CORE_STATS_MEM_SLAB
 		k_obj_core_stats_register(K_OBJ_CORE(slab), &slab->info,
 					  sizeof(struct k_mem_slab_info));
-#endif
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_MEM_SLAB */
+#endif /* CONFIG_OBJ_CORE_MEM_SLAB */
 	}
 
 out:
@@ -182,7 +182,7 @@ int k_mem_slab_init(struct k_mem_slab *slab, void *buffer,
 
 #ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
 	slab->info.max_used = 0U;
-#endif
+#endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */
 
 	rc = create_free_list(slab);
 	if (rc < 0) {
@@ -191,11 +191,11 @@ int k_mem_slab_init(struct k_mem_slab *slab, void *buffer,
 
 #ifdef CONFIG_OBJ_CORE_MEM_SLAB
 	k_obj_core_init_and_link(K_OBJ_CORE(slab), &obj_type_mem_slab);
-#endif
+#endif /* CONFIG_OBJ_CORE_MEM_SLAB */
 #ifdef CONFIG_OBJ_CORE_STATS_MEM_SLAB
 	k_obj_core_stats_register(K_OBJ_CORE(slab), &slab->info,
 				  sizeof(struct k_mem_slab_info));
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_MEM_SLAB */
 
 	z_waitq_init(&slab->wait_q);
 	k_object_init(slab);
@@ -221,7 +221,7 @@ int k_mem_slab_alloc(struct k_mem_slab *slab, void **mem, k_timeout_t timeout)
 #ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
 		slab->info.max_used = MAX(slab->info.num_used,
 					  slab->info.max_used);
-#endif
+#endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */
 
 		result = 0;
 	} else if (K_TIMEOUT_EQ(timeout, K_NO_WAIT) ||
@@ -298,7 +298,7 @@ int k_mem_slab_runtime_stats_get(struct k_mem_slab *slab, struct sys_memory_stat
 				     slab->info.block_size;
 #else
 	stats->max_allocated_bytes = 0;
-#endif
+#endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */
 
 	k_spin_unlock(&slab->lock, key);
 
@@ -320,4 +320,4 @@ int k_mem_slab_runtime_stats_reset_max(struct k_mem_slab *slab)
 
 	return 0;
 }
-#endif
+#endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */

kernel/mempool.c

@@ -119,7 +119,7 @@ void k_thread_system_pool_assign(struct k_thread *thread)
 }
 #else
 #define _SYSTEM_HEAP	NULL
-#endif
+#endif /* K_HEAP_MEM_POOL_SIZE */
 
 void *z_thread_aligned_alloc(size_t align, size_t size)
 {

kernel/mmu.c

@@ -24,7 +24,7 @@ LOG_MODULE_DECLARE(os, CONFIG_KERNEL_LOG_LEVEL);
 
 #ifdef CONFIG_DEMAND_PAGING
 #include <zephyr/kernel/mm/demand_paging.h>
-#endif
+#endif /* CONFIG_DEMAND_PAGING */
 
 /*
  * General terminology:
@@ -76,7 +76,7 @@ static bool page_frames_initialized;
 #define COLOR(x)	printk(_CONCAT(ANSI_, x))
 #else
 #define COLOR(x)	do { } while (false)
-#endif
+#endif /* COLOR_PAGE_FRAMES */
 
 /* LCOV_EXCL_START */
 static void page_frame_dump(struct z_page_frame *pf)
@@ -729,7 +729,7 @@ size_t k_mem_free_get(void)
 	}
 #else
 	ret = z_free_page_count;
-#endif
+#endif /* CONFIG_DEMAND_PAGING */
 	k_spin_unlock(&z_mm_lock, key);
 
 	return ret * (size_t)CONFIG_MMU_PAGE_SIZE;
@@ -767,7 +767,7 @@ void z_phys_map(uint8_t **virt_ptr, uintptr_t phys, size_t size, uint32_t flags)
 
 #ifndef CONFIG_KERNEL_DIRECT_MAP
 	__ASSERT(!(flags & K_MEM_DIRECT_MAP), "The direct-map is not enabled");
-#endif
+#endif /* CONFIG_KERNEL_DIRECT_MAP */
 	addr_offset = k_mem_region_align(&aligned_phys, &aligned_size,
 					 phys, size,
 					 CONFIG_MMU_PAGE_SIZE);
@@ -959,12 +959,12 @@ void z_mem_manage_init(void)
 	 * boot process. Will be un-pinned once boot process completes.
 	 */
 	mark_linker_section_pinned(lnkr_boot_start, lnkr_boot_end, true);
-#endif
+#endif /* CONFIG_LINKER_USE_BOOT_SECTION */
 
 #ifdef CONFIG_LINKER_USE_PINNED_SECTION
 	/* Pin the page frames correspondng to the pinned symbols */
 	mark_linker_section_pinned(lnkr_pinned_start, lnkr_pinned_end, true);
-#endif
+#endif /* CONFIG_LINKER_USE_PINNED_SECTION */
 
 	/* Any remaining pages that aren't mapped, reserved, or pinned get
 	 * added to the free pages list
@@ -979,10 +979,10 @@ void z_mem_manage_init(void)
 #ifdef CONFIG_DEMAND_PAGING
 #ifdef CONFIG_DEMAND_PAGING_TIMING_HISTOGRAM
 	z_paging_histogram_init();
-#endif
+#endif /* CONFIG_DEMAND_PAGING_TIMING_HISTOGRAM */
 	k_mem_paging_backing_store_init();
 	k_mem_paging_eviction_init();
-#endif
+#endif /* CONFIG_DEMAND_PAGING */
 #if __ASSERT_ON
 	page_frames_initialized = true;
 #endif
@@ -996,7 +996,7 @@ void z_mem_manage_init(void)
 	 * memory to be cleared.
 	 */
 	z_bss_zero();
-#endif
+#endif /* CONFIG_LINKER_GENERIC_SECTIONS_PRESENT_AT_BOOT */
 }
 
 void z_mem_manage_boot_finish(void)
@@ -1006,7 +1006,7 @@ void z_mem_manage_boot_finish(void)
 	 * as they don't need to be in memory all the time anymore.
 	 */
 	mark_linker_section_pinned(lnkr_boot_start, lnkr_boot_end, false);
-#endif
+#endif /* CONFIG_LINKER_USE_BOOT_SECTION */
 }
 
 #ifdef CONFIG_DEMAND_PAGING
@@ -1016,7 +1016,7 @@ struct k_mem_paging_stats_t paging_stats;
 extern struct k_mem_paging_histogram_t z_paging_histogram_eviction;
 extern struct k_mem_paging_histogram_t z_paging_histogram_backing_store_page_in;
 extern struct k_mem_paging_histogram_t z_paging_histogram_backing_store_page_out;
-#endif
+#endif /* CONFIG_DEMAND_PAGING_STATS */
 
 static inline void do_backing_store_page_in(uintptr_t location)
 {
@@ -1162,7 +1162,7 @@ static int page_frame_prepare_locked(struct z_page_frame *pf, bool *dirty_ptr,
 	__ASSERT(!z_page_frame_is_busy(pf), "page frame 0x%lx is already busy",
 		 phys);
 	pf->flags |= Z_PAGE_FRAME_BUSY;
-#endif
+#endif /* CONFIG_DEMAND_PAGING_ALLOW_IRQ */
 	/* Update dirty parameter, since we set to true if it wasn't backed
 	 * even if otherwise clean
 	 */
@@ -1320,7 +1320,7 @@ static inline void paging_stats_faults_inc(struct k_thread *faulting_thread,
 	}
 #else
 	ARG_UNUSED(faulting_thread);
-#endif
+#endif /* CONFIG_DEMAND_PAGING_THREAD_STATS */
 
 #ifndef CONFIG_DEMAND_PAGING_ALLOW_IRQ
 	if (k_is_in_isr()) {
@@ -1328,7 +1328,7 @@ static inline void paging_stats_faults_inc(struct k_thread *faulting_thread,
 
 #ifdef CONFIG_DEMAND_PAGING_THREAD_STATS
 		faulting_thread->paging_stats.pagefaults.in_isr++;
-#endif
+#endif /* CONFIG_DEMAND_PAGING_THREAD_STATS */
 	}
 #endif /* CONFIG_DEMAND_PAGING_ALLOW_IRQ */
 #endif /* CONFIG_DEMAND_PAGING_STATS */

kernel/msg_q.c

@@ -27,7 +27,7 @@
 
 #ifdef CONFIG_OBJ_CORE_MSGQ
 static struct k_obj_type obj_type_msgq;
-#endif
+#endif /* CONFIG_OBJ_CORE_MSGQ */
 
 #ifdef CONFIG_POLL
 static inline void handle_poll_events(struct k_msgq *msgq, uint32_t state)
@@ -55,7 +55,7 @@ void k_msgq_init(struct k_msgq *msgq, char *buffer, size_t msg_size,
 
 #ifdef CONFIG_OBJ_CORE_MSGQ
 	k_obj_core_init_and_link(K_OBJ_CORE(msgq), &obj_type_msgq);
-#endif
+#endif /* CONFIG_OBJ_CORE_MSGQ */
 
 	SYS_PORT_TRACING_OBJ_INIT(k_msgq, msgq);
 
@@ -98,7 +98,7 @@ int z_vrfy_k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size,
 	return z_impl_k_msgq_alloc_init(msgq, msg_size, max_msgs);
 }
 #include <syscalls/k_msgq_alloc_init_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int k_msgq_cleanup(struct k_msgq *msgq)
 {
@@ -193,7 +193,7 @@ static inline int z_vrfy_k_msgq_put(struct k_msgq *msgq, const void *data,
 	return z_impl_k_msgq_put(msgq, data, timeout);
 }
 #include <syscalls/k_msgq_put_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 void z_impl_k_msgq_get_attrs(struct k_msgq *msgq, struct k_msgq_attrs *attrs)
 {
@@ -211,7 +211,7 @@ static inline void z_vrfy_k_msgq_get_attrs(struct k_msgq *msgq,
 	z_impl_k_msgq_get_attrs(msgq, attrs);
 }
 #include <syscalls/k_msgq_get_attrs_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int z_impl_k_msgq_get(struct k_msgq *msgq, void *data, k_timeout_t timeout)
 {
@@ -291,7 +291,7 @@ static inline int z_vrfy_k_msgq_get(struct k_msgq *msgq, void *data,
 	return z_impl_k_msgq_get(msgq, data, timeout);
 }
 #include <syscalls/k_msgq_get_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int z_impl_k_msgq_peek(struct k_msgq *msgq, void *data)
 {
@@ -325,7 +325,7 @@ static inline int z_vrfy_k_msgq_peek(struct k_msgq *msgq, void *data)
 	return z_impl_k_msgq_peek(msgq, data);
 }
 #include <syscalls/k_msgq_peek_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int z_impl_k_msgq_peek_at(struct k_msgq *msgq, void *data, uint32_t idx)
 {
@@ -371,7 +371,7 @@ static inline int z_vrfy_k_msgq_peek_at(struct k_msgq *msgq, void *data, uint32_
 	return z_impl_k_msgq_peek_at(msgq, data, idx);
 }
 #include <syscalls/k_msgq_peek_at_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 void z_impl_k_msgq_purge(struct k_msgq *msgq)
 {
@@ -416,7 +416,7 @@ static inline uint32_t z_vrfy_k_msgq_num_used_get(struct k_msgq *msgq)
 }
 #include <syscalls/k_msgq_num_used_get_mrsh.c>
 
-#endif
+#endif /* CONFIG_USERSPACE */
 
 #ifdef CONFIG_OBJ_CORE_MSGQ
 static int init_msgq_obj_core_list(void)
@@ -438,4 +438,4 @@ static int init_msgq_obj_core_list(void)
 SYS_INIT(init_msgq_obj_core_list, PRE_KERNEL_1,
 	 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
 
-#endif
+#endif /* CONFIG_OBJ_CORE_MSGQ */

kernel/mutex.c

@@ -49,7 +49,7 @@ static struct k_spinlock lock;
 
 #ifdef CONFIG_OBJ_CORE_MUTEX
 static struct k_obj_type obj_type_mutex;
-#endif
+#endif /* CONFIG_OBJ_CORE_MUTEX */
 
 int z_impl_k_mutex_init(struct k_mutex *mutex)
 {
@@ -62,7 +62,7 @@ int z_impl_k_mutex_init(struct k_mutex *mutex)
 
 #ifdef CONFIG_OBJ_CORE_MUTEX
 	k_obj_core_init_and_link(K_OBJ_CORE(mutex), &obj_type_mutex);
-#endif
+#endif /* CONFIG_OBJ_CORE_MUTEX */
 
 	SYS_PORT_TRACING_OBJ_INIT(k_mutex, mutex, 0);
 
@@ -76,7 +76,7 @@ static inline int z_vrfy_k_mutex_init(struct k_mutex *mutex)
 	return z_impl_k_mutex_init(mutex);
 }
 #include <syscalls/k_mutex_init_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 static int32_t new_prio_for_inheritance(int32_t target, int32_t limit)
 {
@@ -205,7 +205,7 @@ static inline int z_vrfy_k_mutex_lock(struct k_mutex *mutex,
 	return z_impl_k_mutex_lock(mutex, timeout);
 }
 #include <syscalls/k_mutex_lock_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int z_impl_k_mutex_unlock(struct k_mutex *mutex)
 {
@@ -289,7 +289,7 @@ static inline int z_vrfy_k_mutex_unlock(struct k_mutex *mutex)
 	return z_impl_k_mutex_unlock(mutex);
 }
 #include <syscalls/k_mutex_unlock_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 #ifdef CONFIG_OBJ_CORE_MUTEX
 static int init_mutex_obj_core_list(void)
@@ -310,4 +310,4 @@ static int init_mutex_obj_core_list(void)
 
 SYS_INIT(init_mutex_obj_core_list, PRE_KERNEL_1,
 	 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
-#endif
+#endif /* CONFIG_OBJ_CORE_MUTEX */

kernel/obj_core.c

@@ -28,7 +28,7 @@ void k_obj_core_init(struct k_obj_core *obj_core, struct k_obj_type *type)
 	obj_core->type = type;
 #ifdef CONFIG_OBJ_CORE_STATS
 	obj_core->stats = NULL;
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS */
 }
 
 void k_obj_core_link(struct k_obj_core *obj_core)
@@ -324,4 +324,4 @@ int k_obj_core_stats_enable(struct k_obj_core *obj_core)
 
 	return rv;
 }
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS */

kernel/pipes.c

@@ -33,7 +33,7 @@ static int pipe_get_internal(k_spinlock_key_t key, struct k_pipe *pipe,
 			     k_timeout_t timeout);
 #ifdef CONFIG_OBJ_CORE_PIPE
 static struct k_obj_type obj_type_pipe;
-#endif
+#endif /* CONFIG_OBJ_CORE_PIPE */
 
 
 void k_pipe_init(struct k_pipe *pipe, unsigned char *buffer, size_t size)
@@ -52,12 +52,12 @@ void k_pipe_init(struct k_pipe *pipe, unsigned char *buffer, size_t size)
 
 #if defined(CONFIG_POLL)
 	sys_dlist_init(&pipe->poll_events);
-#endif
+#endif /* CONFIG_POLL */
 	k_object_init(pipe);
 
 #ifdef CONFIG_OBJ_CORE_PIPE
 	k_obj_core_init_and_link(K_OBJ_CORE(pipe), &obj_type_pipe);
-#endif
+#endif /* CONFIG_OBJ_CORE_PIPE */
 }
 
 int z_impl_k_pipe_alloc_init(struct k_pipe *pipe, size_t size)
@@ -94,7 +94,7 @@ static inline int z_vrfy_k_pipe_alloc_init(struct k_pipe *pipe, size_t size)
 	return z_impl_k_pipe_alloc_init(pipe, size);
 }
 #include <syscalls/k_pipe_alloc_init_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 static inline void handle_poll_events(struct k_pipe *pipe)
 {
@@ -102,7 +102,7 @@ static inline void handle_poll_events(struct k_pipe *pipe)
 	z_handle_obj_poll_events(&pipe->poll_events, K_POLL_STATE_PIPE_DATA_AVAILABLE);
 #else
 	ARG_UNUSED(pipe);
-#endif
+#endif /* CONFIG_POLL */
 }
 
 void z_impl_k_pipe_flush(struct k_pipe *pipe)
@@ -127,7 +127,7 @@ void z_vrfy_k_pipe_flush(struct k_pipe *pipe)
 	z_impl_k_pipe_flush(pipe);
 }
 #include <syscalls/k_pipe_flush_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 void z_impl_k_pipe_buffer_flush(struct k_pipe *pipe)
 {
@@ -154,7 +154,7 @@ void z_vrfy_k_pipe_buffer_flush(struct k_pipe *pipe)
 
 	z_impl_k_pipe_buffer_flush(pipe);
 }
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int k_pipe_cleanup(struct k_pipe *pipe)
 {
@@ -526,7 +526,7 @@ int z_vrfy_k_pipe_put(struct k_pipe *pipe, const void *data,
 				 timeout);
 }
 #include <syscalls/k_pipe_put_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 static int pipe_get_internal(k_spinlock_key_t key, struct k_pipe *pipe,
 			     void *data, size_t bytes_to_read,
@@ -734,7 +734,7 @@ int z_vrfy_k_pipe_get(struct k_pipe *pipe, void *data, size_t bytes_to_read,
 				timeout);
 }
 #include <syscalls/k_pipe_get_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 size_t z_impl_k_pipe_read_avail(struct k_pipe *pipe)
 {
@@ -771,7 +771,7 @@ size_t z_vrfy_k_pipe_read_avail(struct k_pipe *pipe)
 	return z_impl_k_pipe_read_avail(pipe);
 }
 #include <syscalls/k_pipe_read_avail_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 size_t z_impl_k_pipe_write_avail(struct k_pipe *pipe)
 {
@@ -808,7 +808,7 @@ size_t z_vrfy_k_pipe_write_avail(struct k_pipe *pipe)
 	return z_impl_k_pipe_write_avail(pipe);
 }
 #include <syscalls/k_pipe_write_avail_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 #ifdef CONFIG_OBJ_CORE_PIPE
 static int init_pipe_obj_core_list(void)
@@ -829,4 +829,4 @@ static int init_pipe_obj_core_list(void)
 
 SYS_INIT(init_pipe_obj_core_list, PRE_KERNEL_1,
 	 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
-#endif
+#endif /* CONFIG_OBJ_CORE_PIPE */

kernel/poll.c

@@ -93,7 +93,7 @@ static inline bool is_condition_met(struct k_poll_event *event, uint32_t *state)
 			*state = K_POLL_STATE_PIPE_DATA_AVAILABLE;
 			return true;
 		}
-#endif
+#endif /* CONFIG_PIPES */
 	case K_POLL_TYPE_IGNORE:
 		break;
 	default:
@@ -159,7 +159,7 @@ static inline void register_event(struct k_poll_event *event,
 		__ASSERT(event->pipe != NULL, "invalid pipe\n");
 		add_event(&event->pipe->poll_events, event, poller);
 		break;
-#endif
+#endif /* CONFIG_PIPES */
 	case K_POLL_TYPE_IGNORE:
 		/* nothing to do */
 		break;
@@ -200,7 +200,7 @@ static inline void clear_event_registration(struct k_poll_event *event)
 		__ASSERT(event->pipe != NULL, "invalid pipe\n");
 		remove_event = true;
 		break;
-#endif
+#endif /* CONFIG_PIPES */
 	case K_POLL_TYPE_IGNORE:
 		/* nothing to do */
 		break;
@@ -417,7 +417,7 @@ static inline int z_vrfy_k_poll(struct k_poll_event *events,
 		case K_POLL_TYPE_PIPE_DATA_AVAILABLE:
 			K_OOPS(K_SYSCALL_OBJ(e->pipe, K_OBJ_PIPE));
 			break;
-#endif
+#endif /* CONFIG_PIPES */
 		default:
 			ret = -EINVAL;
 			goto out_free;
@@ -435,7 +435,7 @@ oops_free:
 	K_OOPS(1);
 }
 #include <syscalls/k_poll_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 /* must be called with interrupts locked */
 static int signal_poll_event(struct k_poll_event *event, uint32_t state)
@@ -494,7 +494,7 @@ static inline void z_vrfy_k_poll_signal_init(struct k_poll_signal *sig)
 	z_impl_k_poll_signal_init(sig);
 }
 #include <syscalls/k_poll_signal_init_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 void z_impl_k_poll_signal_reset(struct k_poll_signal *sig)
 {
@@ -522,7 +522,7 @@ void z_vrfy_k_poll_signal_check(struct k_poll_signal *sig,
 	z_impl_k_poll_signal_check(sig, signaled, result);
 }
 #include <syscalls/k_poll_signal_check_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int z_impl_k_poll_signal_raise(struct k_poll_signal *sig, int result)
 {
@@ -565,7 +565,7 @@ static inline void z_vrfy_k_poll_signal_reset(struct k_poll_signal *sig)
 }
 #include <syscalls/k_poll_signal_reset_mrsh.c>
 
-#endif
+#endif /* CONFIG_USERSPACE */
 
 static void triggered_work_handler(struct k_work *work)
 {

kernel/queue.c

@@ -76,7 +76,7 @@ static inline void z_vrfy_k_queue_init(struct k_queue *queue)
 	z_impl_k_queue_init(queue);
 }
 #include <syscalls/k_queue_init_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 static void prepare_thread_to_run(struct k_thread *thread, void *data)
 {
@@ -91,7 +91,7 @@ static inline void handle_poll_events(struct k_queue *queue, uint32_t state)
 #else
 	ARG_UNUSED(queue);
 	ARG_UNUSED(state);
-#endif
+#endif /* CONFIG_POLL */
 }
 
 void z_impl_k_queue_cancel_wait(struct k_queue *queue)
@@ -118,7 +118,7 @@ static inline void z_vrfy_k_queue_cancel_wait(struct k_queue *queue)
 	z_impl_k_queue_cancel_wait(queue);
 }
 #include <syscalls/k_queue_cancel_wait_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 static int32_t queue_insert(struct k_queue *queue, void *prev, void *data,
 			    bool alloc, bool is_append)
@@ -221,7 +221,7 @@ static inline int32_t z_vrfy_k_queue_alloc_append(struct k_queue *queue,
 	return z_impl_k_queue_alloc_append(queue, data);
 }
 #include <syscalls/k_queue_alloc_append_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int32_t z_impl_k_queue_alloc_prepend(struct k_queue *queue, void *data)
 {
@@ -242,7 +242,7 @@ static inline int32_t z_vrfy_k_queue_alloc_prepend(struct k_queue *queue,
 	return z_impl_k_queue_alloc_prepend(queue, data);
 }
 #include <syscalls/k_queue_alloc_prepend_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int k_queue_append_list(struct k_queue *queue, void *head, void *tail)
 {
@@ -454,7 +454,7 @@ static int init_fifo_obj_core_list(void)
 
 SYS_INIT(init_fifo_obj_core_list, PRE_KERNEL_1,
 	 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
-#endif
+#endif /* CONFIG_OBJ_CORE_FIFO */
 
 #ifdef CONFIG_OBJ_CORE_LIFO
 struct k_obj_type _obj_type_lifo;
@@ -477,4 +477,4 @@ static int init_lifo_obj_core_list(void)
 
 SYS_INIT(init_lifo_obj_core_list, PRE_KERNEL_1,
 	 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
-#endif
+#endif /* CONFIG_OBJ_CORE_LIFO */

kernel/sched.c

@@ -50,7 +50,7 @@ static inline int is_metairq(struct k_thread *thread)
 #else
 	ARG_UNUSED(thread);
 	return 0;
-#endif
+#endif /* CONFIG_NUM_METAIRQ_PRIORITIES */
 }
 
 #if CONFIG_ASSERT
@@ -58,7 +58,7 @@ static inline bool is_thread_dummy(struct k_thread *thread)
 {
 	return (thread->base.thread_state & _THREAD_DUMMY) != 0U;
 }
-#endif
+#endif /* CONFIG_ASSERT */
 
 /*
  * Return value same as e.g. memcmp
@@ -98,7 +98,7 @@ int32_t z_sched_prio_cmp(struct k_thread *thread_1,
 		 */
 		return (int32_t) (d2 - d1);
 	}
-#endif
+#endif /* CONFIG_SCHED_DEADLINE */
 	return 0;
 }
 
@@ -154,7 +154,7 @@ static ALWAYS_INLINE struct k_thread *_priq_dumb_mask_best(sys_dlist_t *pq)
 	}
 	return NULL;
 }
-#endif
+#endif /* CONFIG_SCHED_CPU_MASK */
 
 #if defined(CONFIG_SCHED_DUMB) || defined(CONFIG_WAITQ_DUMB)
 static ALWAYS_INLINE void z_priq_dumb_add(sys_dlist_t *pq,
@@ -174,7 +174,7 @@ static ALWAYS_INLINE void z_priq_dumb_add(sys_dlist_t *pq,
 
 	sys_dlist_append(pq, &thread->base.qnode_dlist);
 }
-#endif
+#endif /* CONFIG_SCHED_DUMB || CONFIG_WAITQ_DUMB */
 
 static ALWAYS_INLINE void *thread_runq(struct k_thread *thread)
 {
@@ -193,7 +193,7 @@ static ALWAYS_INLINE void *thread_runq(struct k_thread *thread)
 #else
 	ARG_UNUSED(thread);
 	return &_kernel.ready_q.runq;
-#endif
+#endif /* CONFIG_SCHED_CPU_MASK_PIN_ONLY */
 }
 
 static ALWAYS_INLINE void *curr_cpu_runq(void)
@@ -202,7 +202,7 @@ static ALWAYS_INLINE void *curr_cpu_runq(void)
 	return &arch_curr_cpu()->ready_q.runq;
 #else
 	return &_kernel.ready_q.runq;
-#endif
+#endif /* CONFIG_SCHED_CPU_MASK_PIN_ONLY */
 }
 
 static ALWAYS_INLINE void runq_add(struct k_thread *thread)
@@ -239,7 +239,7 @@ static ALWAYS_INLINE void queue_thread(struct k_thread *thread)
 		/* add current to end of queue means "yield" */
 		_current_cpu->swap_ok = true;
 	}
-#endif
+#endif /* CONFIG_SMP */
 }
 
 static ALWAYS_INLINE void dequeue_thread(struct k_thread *thread)
@@ -266,7 +266,7 @@ static void signal_pending_ipi(void)
 			arch_sched_ipi();
 		}
 	}
-#endif
+#endif /* CONFIG_SMP && CONFIG_SCHED_IPI_SUPPORTED */
 }
 
 #ifdef CONFIG_SMP
@@ -296,7 +296,7 @@ static inline bool is_halting(struct k_thread *thread)
 	return (thread->base.thread_state &
 		(_THREAD_ABORTING | _THREAD_SUSPENDING)) != 0U;
 }
-#endif
+#endif /* CONFIG_SMP */
 
 /* Clear the halting bits (_THREAD_ABORTING and _THREAD_SUSPENDING) */
 static inline void clear_halting(struct k_thread *thread)
@@ -311,7 +311,7 @@ static ALWAYS_INLINE struct k_thread *next_up(void)
 		halt_thread(_current, is_aborting(_current) ?
 				      _THREAD_DEAD : _THREAD_SUSPENDED);
 	}
-#endif
+#endif /* CONFIG_SMP */
 
 	struct k_thread *thread = runq_best();
 
@@ -332,6 +332,9 @@ static ALWAYS_INLINE struct k_thread *next_up(void)
 		}
 	}
 #endif
+/* CONFIG_NUM_METAIRQ_PRIORITIES > 0 &&
+ * CONFIG_NUM_COOP_PRIORITIES > CONFIG_NUM_METAIRQ_PRIORITIES
+ */
 
 #ifndef CONFIG_SMP
 	/* In uniprocessor mode, we can leave the current thread in
@@ -386,7 +389,7 @@ static ALWAYS_INLINE struct k_thread *next_up(void)
 
 	_current_cpu->swap_ok = false;
 	return thread;
-#endif
+#endif /* CONFIG_SMP */
 }
 
 static void move_thread_to_end_of_prio_q(struct k_thread *thread)
@@ -404,7 +407,7 @@ static void flag_ipi(void)
 	if (arch_num_cpus() > 1) {
 		_kernel.pending_ipi = true;
 	}
-#endif
+#endif /* CONFIG_SMP && CONFIG_SCHED_IPI_SUPPORTED */
 }
 
 #ifdef CONFIG_TIMESLICING
@@ -421,7 +424,7 @@ static bool slice_expired[CONFIG_MP_MAX_NUM_CPUS];
  * a noop condition in z_time_slice().
  */
 static struct k_thread *pending_current;
-#endif
+#endif /* CONFIG_SWAP_NONATOMIC */
 
 static inline int slice_time(struct k_thread *thread)
 {
@@ -433,7 +436,7 @@ static inline int slice_time(struct k_thread *thread)
 	}
 #else
 	ARG_UNUSED(thread);
-#endif
+#endif /* CONFIG_TIMESLICE_PER_THREAD */
 	return ret;
 }
 
@@ -447,7 +450,7 @@ static inline bool sliceable(struct k_thread *thread)
 
 #ifdef CONFIG_TIMESLICE_PER_THREAD
 	ret |= thread->base.slice_ticks != 0;
-#endif
+#endif /* CONFIG_TIMESLICE_PER_THREAD */
 
 	return ret;
 }
@@ -498,7 +501,7 @@ void k_thread_time_slice_set(struct k_thread *thread, int32_t thread_slice_ticks
 		thread->base.slice_data = data;
 	}
 }
-#endif
+#endif /* CONFIG_TIMESLICE_PER_THREAD */
 
 /* Called out of each timer interrupt */
 void z_time_slice(void)
@@ -513,7 +516,7 @@ void z_time_slice(void)
 		return;
 	}
 	pending_current = NULL;
-#endif
+#endif /* CONFIG_SWAP_NONATOMIC */
 
 	if (slice_expired[_current_cpu->id] && sliceable(curr)) {
 #ifdef CONFIG_TIMESLICE_PER_THREAD
@@ -522,7 +525,7 @@ void z_time_slice(void)
 			curr->base.slice_expired(curr, curr->base.slice_data);
 			key = k_spin_lock(&_sched_spinlock);
 		}
-#endif
+#endif /* CONFIG_TIMESLICE_PER_THREAD */
 		if (!z_is_thread_prevented_from_running(curr)) {
 			move_thread_to_end_of_prio_q(curr);
 		}
@@ -530,7 +533,7 @@ void z_time_slice(void)
 	}
 	k_spin_unlock(&_sched_spinlock, key);
 }
-#endif
+#endif /* CONFIG_TIMESLICING */
 
 /* Track cooperative threads preempted by metairqs so we can return to
  * them specifically.  Called at the moment a new thread has been
@@ -551,6 +554,9 @@ static void update_metairq_preempt(struct k_thread *thread)
 #else
 	ARG_UNUSED(thread);
 #endif
+/* CONFIG_NUM_METAIRQ_PRIORITIES > 0 &&
+ * CONFIG_NUM_COOP_PRIORITIES > CONFIG_NUM_METAIRQ_PRIORITIES
+ */
 }
 
 static void update_cache(int preempt_ok)
@@ -563,7 +569,7 @@ static void update_cache(int preempt_ok)
 		if (thread != _current) {
 			z_reset_time_slice(thread);
 		}
-#endif
+#endif /* CONFIG_TIMESLICING */
 		update_metairq_preempt(thread);
 		_kernel.ready_q.cache = thread;
 	} else {
@@ -578,7 +584,7 @@ static void update_cache(int preempt_ok)
 	 * reason the scheduler will make the same decision anyway.
 	 */
 	_current_cpu->swap_ok = preempt_ok;
-#endif
+#endif /* CONFIG_SMP */
 }
 
 static bool thread_active_elsewhere(struct k_thread *thread)
@@ -598,7 +604,7 @@ static bool thread_active_elsewhere(struct k_thread *thread)
 			return true;
 		}
 	}
-#endif
+#endif /* CONFIG_SMP */
 	ARG_UNUSED(thread);
 	return false;
 }
@@ -607,7 +613,7 @@ static void ready_thread(struct k_thread *thread)
 {
 #ifdef CONFIG_KERNEL_COHERENCE
 	__ASSERT_NO_MSG(arch_mem_coherent(thread));
-#endif
+#endif /* CONFIG_KERNEL_COHERENCE */
 
 	/* If thread is queued already, do not try and added it to the
 	 * run queue again
@@ -693,7 +699,7 @@ static void z_thread_halt(struct k_thread *thread, k_spinlock_key_t key,
 		 */
 #ifdef CONFIG_SCHED_IPI_SUPPORTED
 		arch_sched_ipi();
-#endif
+#endif /* CONFIG_SCHED_IPI_SUPPORTED */
 	}
 
 	if (is_halting(thread) && (thread != _current)) {
@@ -719,7 +725,7 @@ static void z_thread_halt(struct k_thread *thread, k_spinlock_key_t key,
 		}
 		return; /* lock has been released */
 	}
-#endif
+#endif /* CONFIG_SMP */
 	halt_thread(thread, terminate ? _THREAD_DEAD : _THREAD_SUSPENDED);
 	if ((thread == _current) && !arch_is_in_isr()) {
 		z_swap(&_sched_spinlock, key);
@@ -757,7 +763,7 @@ static inline void z_vrfy_k_thread_suspend(struct k_thread *thread)
 	z_impl_k_thread_suspend(thread);
 }
 #include <syscalls/k_thread_suspend_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 void z_impl_k_thread_resume(struct k_thread *thread)
 {
@@ -786,7 +792,7 @@ static inline void z_vrfy_k_thread_resume(struct k_thread *thread)
 	z_impl_k_thread_resume(thread);
 }
 #include <syscalls/k_thread_resume_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 static _wait_q_t *pended_on_thread(struct k_thread *thread)
 {
@@ -829,7 +835,7 @@ static void pend_locked(struct k_thread *thread, _wait_q_t *wait_q,
 {
 #ifdef CONFIG_KERNEL_COHERENCE
 	__ASSERT_NO_MSG(wait_q == NULL || arch_mem_coherent(wait_q));
-#endif
+#endif /* CONFIG_KERNEL_COHERENCE */
 	add_to_waitq_locked(thread, wait_q);
 	add_thread_timeout(thread, timeout);
 }
@@ -873,7 +879,7 @@ void z_sched_wake_thread(struct k_thread *thread, bool is_timeout)
 		if (do_nothing) {
 			continue;
 		}
-#endif
+#endif /* CONFIG_EVENTS */
 
 		if (!killed) {
 			/* The thread is not being killed */
@@ -899,14 +905,14 @@ void z_thread_timeout(struct _timeout *timeout)
 
 	z_sched_wake_thread(thread, true);
 }
-#endif
+#endif /* CONFIG_SYS_CLOCK_EXISTS */
 
 int z_pend_curr(struct k_spinlock *lock, k_spinlock_key_t key,
 	       _wait_q_t *wait_q, k_timeout_t timeout)
 {
 #if defined(CONFIG_TIMESLICING) && defined(CONFIG_SWAP_NONATOMIC)
 	pending_current = _current;
-#endif
+#endif /* CONFIG_TIMESLICING && CONFIG_SWAP_NONATOMIC */
 	__ASSERT_NO_MSG(sizeof(_sched_spinlock) == 0 || lock != &_sched_spinlock);
 
 	/* We do a "lock swap" prior to calling z_swap(), such that
@@ -994,7 +1000,7 @@ static inline bool resched(uint32_t key)
 {
 #ifdef CONFIG_SMP
 	_current_cpu->swap_ok = 0;
-#endif
+#endif /* CONFIG_SMP */
 
 	return arch_irq_unlocked(key) && !arch_is_in_isr();
 }
@@ -1014,7 +1020,7 @@ static inline bool need_swap(void)
 	/* Check if the next ready thread is the same as the current thread */
 	new_thread = _kernel.ready_q.cache;
 	return new_thread != _current;
-#endif
+#endif /* CONFIG_SMP */
 }
 
 void z_reschedule(struct k_spinlock *lock, k_spinlock_key_t key)
@@ -1079,7 +1085,7 @@ struct k_thread *z_swap_next_thread(void)
 	return ret;
 #else
 	return _kernel.ready_q.cache;
-#endif
+#endif /* CONFIG_SMP */
 }
 
 #ifdef CONFIG_USE_SWITCH
@@ -1148,7 +1154,7 @@ void *z_get_next_switch_handle(void *interrupted)
 
 #ifdef CONFIG_TIMESLICING
 			z_reset_time_slice(new_thread);
-#endif
+#endif /* CONFIG_TIMESLICING */
 
 #ifdef CONFIG_SPIN_VALIDATE
 			/* Changed _current!  Update the spinlock
@@ -1157,7 +1163,7 @@ void *z_get_next_switch_handle(void *interrupted)
 			 * release the lock.
 			 */
 			z_spin_lock_set_owner(&_sched_spinlock);
-#endif
+#endif /* CONFIG_SPIN_VALIDATE */
 
 			/* A queued (runnable) old/current thread
 			 * needs to be added back to the run queue
@@ -1183,9 +1189,9 @@ void *z_get_next_switch_handle(void *interrupted)
 	_current->switch_handle = interrupted;
 	set_current(_kernel.ready_q.cache);
 	return _current->switch_handle;
-#endif
+#endif /* CONFIG_SMP */
 }
-#endif
+#endif /* CONFIG_USE_SWITCH */
 
 int z_unpend_all(_wait_q_t *wait_q)
 {
@@ -1226,7 +1232,7 @@ void z_sched_init(void)
 	}
 #else
 	init_ready_q(&_kernel.ready_q);
-#endif
+#endif /* CONFIG_SCHED_CPU_MASK_PIN_ONLY */
 }
 
 int z_impl_k_thread_priority_get(k_tid_t thread)
@@ -1241,7 +1247,7 @@ static inline int z_vrfy_k_thread_priority_get(k_tid_t thread)
 	return z_impl_k_thread_priority_get(thread);
 }
 #include <syscalls/k_thread_priority_get_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 void z_impl_k_thread_priority_set(k_tid_t thread, int prio)
 {
@@ -1270,11 +1276,11 @@ static inline void z_vrfy_k_thread_priority_set(k_tid_t thread, int prio)
 	K_OOPS(K_SYSCALL_VERIFY_MSG((int8_t)prio >= thread->base.prio,
 				    "thread priority may only be downgraded (%d < %d)",
 				    prio, thread->base.prio));
-#endif
+#endif /* CONFIG_USERSPACE_THREAD_MAY_RAISE_PRIORITY */
 	z_impl_k_thread_priority_set(thread, prio);
 }
 #include <syscalls/k_thread_priority_set_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 #ifdef CONFIG_SCHED_DEADLINE
 void z_impl_k_thread_deadline_set(k_tid_t tid, int deadline)
@@ -1312,8 +1318,8 @@ static inline void z_vrfy_k_thread_deadline_set(k_tid_t tid, int deadline)
 	z_impl_k_thread_deadline_set((k_tid_t)thread, deadline);
 }
 #include <syscalls/k_thread_deadline_set_mrsh.c>
-#endif
-#endif
+#endif /* CONFIG_USERSPACE */
+#endif /* CONFIG_SCHED_DEADLINE */
 
 bool k_can_yield(void)
 {
@@ -1344,7 +1350,7 @@ static inline void z_vrfy_k_yield(void)
 	z_impl_k_yield();
 }
 #include <syscalls/k_yield_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 static int32_t z_tick_sleep(k_ticks_t ticks)
 {
@@ -1360,7 +1366,7 @@ static int32_t z_tick_sleep(k_ticks_t ticks)
 		k_yield();
 		return 0;
 	}
-#endif
+#endif /* CONFIG_MULTITHREADING */
 
 	if (Z_TICK_ABS(ticks) <= 0) {
 		expected_wakeup_ticks = ticks + sys_clock_tick_get_32();
@@ -1374,7 +1380,7 @@ static int32_t z_tick_sleep(k_ticks_t ticks)
 
 #if defined(CONFIG_TIMESLICING) && defined(CONFIG_SWAP_NONATOMIC)
 	pending_current = _current;
-#endif
+#endif /* CONFIG_TIMESLICING && CONFIG_SWAP_NONATOMIC */
 	unready_thread(_current);
 	z_add_thread_timeout(_current, timeout);
 	z_mark_thread_as_suspended(_current);
@@ -1390,7 +1396,7 @@ static int32_t z_tick_sleep(k_ticks_t ticks)
 #else
 	/* busy wait to be time coherent since subsystems may depend on it */
 	z_impl_k_busy_wait(k_ticks_to_us_ceil32(expected_wakeup_ticks));
-#endif
+#endif /* CONFIG_MULTITHREADING */
 
 	return 0;
 }
@@ -1410,7 +1416,7 @@ int32_t z_impl_k_sleep(k_timeout_t timeout)
 #else
 		/* In Single Thread, just wait for an interrupt saving power */
 		k_cpu_idle();
-#endif
+#endif /* CONFIG_MULTITHREADING */
 		SYS_PORT_TRACING_FUNC_EXIT(k_thread, sleep, timeout, (int32_t) K_TICKS_FOREVER);
 
 		return (int32_t) K_TICKS_FOREVER;
@@ -1433,7 +1439,7 @@ static inline int32_t z_vrfy_k_sleep(k_timeout_t timeout)
 	return z_impl_k_sleep(timeout);
 }
 #include <syscalls/k_sleep_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int32_t z_impl_k_usleep(int us)
 {
@@ -1457,7 +1463,7 @@ static inline int32_t z_vrfy_k_usleep(int us)
 	return z_impl_k_usleep(us);
 }
 #include <syscalls/k_usleep_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 void z_impl_k_wakeup(k_tid_t thread)
 {
@@ -1491,7 +1497,7 @@ void z_impl_k_wakeup(k_tid_t thread)
 
 #ifdef CONFIG_TRACE_SCHED_IPI
 extern void z_trace_sched_ipi(void);
-#endif
+#endif /* CONFIG_TRACE_SCHED_IPI */
 
 #ifdef CONFIG_SMP
 void z_sched_ipi(void)
@@ -1501,15 +1507,15 @@ void z_sched_ipi(void)
 	 */
 #ifdef CONFIG_TRACE_SCHED_IPI
 	z_trace_sched_ipi();
-#endif
+#endif /* CONFIG_TRACE_SCHED_IPI */
 
 #ifdef CONFIG_TIMESLICING
 	if (sliceable(_current)) {
 		z_time_slice();
 	}
-#endif
+#endif /* CONFIG_TIMESLICING */
 }
-#endif
+#endif /* CONFIG_SMP */
 
 #ifdef CONFIG_USERSPACE
 static inline void z_vrfy_k_wakeup(k_tid_t thread)
@@ -1518,7 +1524,7 @@ static inline void z_vrfy_k_wakeup(k_tid_t thread)
 	z_impl_k_wakeup(thread);
 }
 #include <syscalls/k_wakeup_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 k_tid_t z_impl_k_sched_current_thread_query(void)
 {
@@ -1528,13 +1534,13 @@ k_tid_t z_impl_k_sched_current_thread_query(void)
 	 * local interrupts when reading it.
 	 */
 	unsigned int k = arch_irq_lock();
-#endif
+#endif /* CONFIG_SMP */
 
 	k_tid_t ret = _current_cpu->current;
 
 #ifdef CONFIG_SMP
 	arch_irq_unlock(k);
-#endif
+#endif /* CONFIG_SMP */
 	return ret;
 }
 
@@ -1544,7 +1550,7 @@ static inline k_tid_t z_vrfy_k_sched_current_thread_query(void)
 	return z_impl_k_sched_current_thread_query();
 }
 #include <syscalls/k_sched_current_thread_query_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int z_impl_k_is_preempt_thread(void)
 {
@@ -1557,7 +1563,7 @@ static inline int z_vrfy_k_is_preempt_thread(void)
 	return z_impl_k_is_preempt_thread();
 }
 #include <syscalls/k_is_preempt_thread_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 static inline void unpend_all(_wait_q_t *wait_q)
 {
@@ -1573,7 +1579,7 @@ static inline void unpend_all(_wait_q_t *wait_q)
 
 #ifdef CONFIG_THREAD_ABORT_HOOK
 extern void thread_abort_hook(struct k_thread *thread);
-#endif
+#endif /* CONFIG_THREAD_ABORT_HOOK */
 
 /**
  * @brief Dequeues the specified thread
@@ -1604,7 +1610,7 @@ static void halt_thread(struct k_thread *thread, uint8_t new_state)
 		}
 #ifdef CONFIG_SMP
 		unpend_all(&thread->halt_queue);
-#endif
+#endif /* CONFIG_SMP */
 		update_cache(1);
 
 		if (new_state == _THREAD_SUSPENDED) {
@@ -1613,28 +1619,28 @@ static void halt_thread(struct k_thread *thread, uint8_t new_state)
 
 #if defined(CONFIG_FPU) && defined(CONFIG_FPU_SHARING)
 		arch_float_disable(thread);
-#endif
+#endif /* CONFIG_FPU && CONFIG_FPU_SHARING */
 
 		SYS_PORT_TRACING_FUNC(k_thread, sched_abort, thread);
 
 		z_thread_monitor_exit(thread);
 #ifdef CONFIG_THREAD_ABORT_HOOK
 		thread_abort_hook(thread);
-#endif
+#endif /* CONFIG_THREAD_ABORT_HOOK */
 
 #ifdef CONFIG_OBJ_CORE_THREAD
 #ifdef CONFIG_OBJ_CORE_STATS_THREAD
 		k_obj_core_stats_deregister(K_OBJ_CORE(thread));
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_THREAD */
 		k_obj_core_unlink(K_OBJ_CORE(thread));
-#endif
+#endif /* CONFIG_OBJ_CORE_THREAD */
 
 #ifdef CONFIG_USERSPACE
 		z_mem_domain_exit_thread(thread);
 		k_thread_perms_all_clear(thread);
 		k_object_uninit(thread->stack_obj);
 		k_object_uninit(thread);
-#endif
+#endif /* CONFIG_USERSPACE */
 	}
 }
 
@@ -1666,7 +1672,7 @@ void z_impl_k_thread_abort(struct k_thread *thread)
 
 	SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_thread, abort, thread);
 }
-#endif
+#endif /* !CONFIG_ARCH_HAS_THREAD_ABORT */
 
 int z_impl_k_thread_join(struct k_thread *thread, k_timeout_t timeout)
 {
@@ -1723,7 +1729,7 @@ static bool thread_obj_validate(struct k_thread *thread)
 	default:
 #ifdef CONFIG_LOG
 		k_object_dump_error(ret, thread, ko, K_OBJ_THREAD);
-#endif
+#endif /* CONFIG_LOG */
 		K_OOPS(K_SYSCALL_VERIFY_MSG(ret, "access denied"));
 	}
 	CODE_UNREACHABLE; /* LCOV_EXCL_LINE */

kernel/sem.c

@@ -40,7 +40,7 @@ static struct k_spinlock lock;
 
 #ifdef CONFIG_OBJ_CORE_SEM
 static struct k_obj_type obj_type_sem;
-#endif
+#endif /* CONFIG_OBJ_CORE_SEM */
 
 int z_impl_k_sem_init(struct k_sem *sem, unsigned int initial_count,
 		      unsigned int limit)
@@ -62,12 +62,12 @@ int z_impl_k_sem_init(struct k_sem *sem, unsigned int initial_count,
 	z_waitq_init(&sem->wait_q);
 #if defined(CONFIG_POLL)
 	sys_dlist_init(&sem->poll_events);
-#endif
+#endif /* CONFIG_POLL */
 	k_object_init(sem);
 
 #ifdef CONFIG_OBJ_CORE_SEM
 	k_obj_core_init_and_link(K_OBJ_CORE(sem), &obj_type_sem);
-#endif
+#endif /* CONFIG_OBJ_CORE_SEM */
 
 	return 0;
 }
@@ -80,7 +80,7 @@ int z_vrfy_k_sem_init(struct k_sem *sem, unsigned int initial_count,
 	return z_impl_k_sem_init(sem, initial_count, limit);
 }
 #include <syscalls/k_sem_init_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 static inline bool handle_poll_events(struct k_sem *sem)
 {
@@ -90,7 +90,7 @@ static inline bool handle_poll_events(struct k_sem *sem)
 #else
 	ARG_UNUSED(sem);
 	return false;
-#endif
+#endif /* CONFIG_POLL */
 }
 
 void z_impl_k_sem_give(struct k_sem *sem)
@@ -127,7 +127,7 @@ static inline void z_vrfy_k_sem_give(struct k_sem *sem)
 	z_impl_k_sem_give(sem);
 }
 #include <syscalls/k_sem_give_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int z_impl_k_sem_take(struct k_sem *sem, k_timeout_t timeout)
 {
@@ -207,7 +207,7 @@ static inline unsigned int z_vrfy_k_sem_count_get(struct k_sem *sem)
 }
 #include <syscalls/k_sem_count_get_mrsh.c>
 
-#endif
+#endif /* CONFIG_USERSPACE */
 
 #ifdef CONFIG_OBJ_CORE_SEM
 static int init_sem_obj_core_list(void)
@@ -228,4 +228,4 @@ static int init_sem_obj_core_list(void)
 
 SYS_INIT(init_sem_obj_core_list, PRE_KERNEL_1,
 	 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
-#endif
+#endif /* CONFIG_OBJ_CORE_SEM */

kernel/smp.c

@@ -49,7 +49,7 @@ static struct cpu_start_cb {
 #ifdef CONFIG_SYS_CLOCK_EXISTS
 	/** True if smp_timer_init() needs to be called. */
 	bool reinit_timer;
-#endif
+#endif /* CONFIG_SYS_CLOCK_EXISTS */
 } cpu_start_fn;
 
 static struct k_spinlock cpu_start_lock;
@@ -130,7 +130,7 @@ static inline void smp_init_top(void *arg)
 	if ((arg == NULL) || csc.reinit_timer) {
 		smp_timer_init();
 	}
-#endif
+#endif /* CONFIG_SYS_CLOCK_EXISTS */
 
 	/* Do additional initialization steps if needed. */
 	if (csc.fn != NULL) {
@@ -177,7 +177,7 @@ void k_smp_cpu_start(int id, smp_init_fn fn, void *arg)
 
 #ifdef CONFIG_SYS_CLOCK_EXISTS
 	cpu_start_fn.reinit_timer = true;
-#endif
+#endif /* CONFIG_SYS_CLOCK_EXISTS */
 
 	/* We are only starting one CPU so we do not need to synchronize
 	 * across all CPUs using the start_flag. So just set it to 1.
@@ -206,7 +206,7 @@ void k_smp_cpu_resume(int id, smp_init_fn fn, void *arg,
 	cpu_start_fn.reinit_timer = reinit_timer;
 #else
 	ARG_UNUSED(reinit_timer);
-#endif
+#endif /* CONFIG_SYS_CLOCK_EXISTS */
 
 	/* We are only starting one CPU so we do not need to synchronize
 	 * across all CPUs using the start_flag. So just set it to 1.

kernel/stack.c

@@ -21,7 +21,7 @@
 
 #ifdef CONFIG_OBJ_CORE_STACK
 static struct k_obj_type obj_type_stack;
-#endif
+#endif /* CONFIG_OBJ_CORE_STACK */
 
 void k_stack_init(struct k_stack *stack, stack_data_t *buffer,
 		  uint32_t num_entries)
@@ -36,7 +36,7 @@ void k_stack_init(struct k_stack *stack, stack_data_t *buffer,
 
 #ifdef CONFIG_OBJ_CORE_STACK
 	k_obj_core_init_and_link(K_OBJ_CORE(stack), &obj_type_stack);
-#endif
+#endif /* CONFIG_OBJ_CORE_STACK */
 }
 
 int32_t z_impl_k_stack_alloc_init(struct k_stack *stack, uint32_t num_entries)
@@ -69,7 +69,7 @@ static inline int32_t z_vrfy_k_stack_alloc_init(struct k_stack *stack,
 	return z_impl_k_stack_alloc_init(stack, num_entries);
 }
 #include <syscalls/k_stack_alloc_init_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int k_stack_cleanup(struct k_stack *stack)
 {
@@ -137,7 +137,7 @@ static inline int z_vrfy_k_stack_push(struct k_stack *stack, stack_data_t data)
 	return z_impl_k_stack_push(stack, data);
 }
 #include <syscalls/k_stack_push_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 int z_impl_k_stack_pop(struct k_stack *stack, stack_data_t *data,
 		       k_timeout_t timeout)
@@ -192,7 +192,7 @@ static inline int z_vrfy_k_stack_pop(struct k_stack *stack,
 	return z_impl_k_stack_pop(stack, data, timeout);
 }
 #include <syscalls/k_stack_pop_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 #ifdef CONFIG_OBJ_CORE_STACK
 static int init_stack_obj_core_list(void)
@@ -213,4 +213,4 @@ static int init_stack_obj_core_list(void)
 
 SYS_INIT(init_stack_obj_core_list, PRE_KERNEL_1,
 	 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
-#endif
+#endif /* CONFIG_OBJ_CORE_STACK */

kernel/thread.c

@@ -47,7 +47,7 @@ static struct k_obj_core_stats_desc  thread_stats_desc = {
 	.disable = z_thread_stats_disable,
 	.enable  = z_thread_stats_enable,
 };
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_THREAD */
 
 static int init_thread_obj_core_list(void)
 {
@@ -56,18 +56,18 @@ static int init_thread_obj_core_list(void)
 #ifdef CONFIG_OBJ_CORE_THREAD
 	z_obj_type_init(&obj_type_thread, K_OBJ_TYPE_THREAD_ID,
 			offsetof(struct k_thread, obj_core));
-#endif
+#endif /* CONFIG_OBJ_CORE_THREAD */
 
 #ifdef CONFIG_OBJ_CORE_STATS_THREAD
 	k_obj_type_stats_init(&obj_type_thread, &thread_stats_desc);
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_THREAD */
 
 	return 0;
 }
 
 SYS_INIT(init_thread_obj_core_list, PRE_KERNEL_1,
 	 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
-#endif
+#endif /* CONFIG_OBJ_CORE_THREAD */
 
 
 #define _FOREACH_STATIC_THREAD(thread_data)              \
@@ -91,7 +91,7 @@ static inline void z_vrfy_k_thread_custom_data_set(void *data)
 	z_impl_k_thread_custom_data_set(data);
 }
 #include <syscalls/k_thread_custom_data_set_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 void *z_impl_k_thread_custom_data_get(void)
 {
@@ -338,8 +338,8 @@ static inline void z_vrfy_k_thread_start(struct k_thread *thread)
 	return z_impl_k_thread_start(thread);
 }
 #include <syscalls/k_thread_start_mrsh.c>
-#endif
-#endif
+#endif /* CONFIG_USERSPACE */
+#endif /* CONFIG_MULTITHREADING */
 
 
 #if CONFIG_STACK_POINTER_RANDOM
@@ -388,7 +388,7 @@ static char *setup_thread_stack(struct k_thread *new_thread,
 		stack_buf_start = Z_THREAD_STACK_BUFFER(stack);
 		stack_buf_size = stack_obj_size - K_THREAD_STACK_RESERVED;
 	} else
-#endif
+#endif /* CONFIG_USERSPACE */
 	{
 		/* Object cannot host a user mode thread */
 		stack_obj_size = Z_KERNEL_STACK_SIZE_ADJUST(stack_size);
@@ -417,7 +417,7 @@ static char *setup_thread_stack(struct k_thread *new_thread,
 
 #ifdef CONFIG_INIT_STACKS
 	memset(stack_buf_start, 0xaa, stack_buf_size);
-#endif
+#endif /* CONFIG_INIT_STACKS */
 #ifdef CONFIG_STACK_SENTINEL
 	/* Put the stack sentinel at the lowest 4 bytes of the stack area.
 	 * We periodically check that it's still present and kill the thread
@@ -436,10 +436,10 @@ static char *setup_thread_stack(struct k_thread *new_thread,
 	delta += tls_size;
 	new_thread->userspace_local_data =
 		(struct _thread_userspace_local_data *)(stack_ptr - delta);
-#endif
+#endif /* CONFIG_THREAD_USERSPACE_LOCAL_DATA */
 #if CONFIG_STACK_POINTER_RANDOM
 	delta += random_offset(stack_buf_size);
-#endif
+#endif /* CONFIG_STACK_POINTER_RANDOM */
 	delta = ROUND_UP(delta, ARCH_STACK_PTR_ALIGN);
 #ifdef CONFIG_THREAD_STACK_INFO
 	/* Initial values. Arches which implement MPU guards that "borrow"
@@ -452,7 +452,7 @@ static char *setup_thread_stack(struct k_thread *new_thread,
 	new_thread->stack_info.start = (uintptr_t)stack_buf_start;
 	new_thread->stack_info.size = stack_buf_size;
 	new_thread->stack_info.delta = delta;
-#endif
+#endif /* CONFIG_THREAD_STACK_INFO */
 	stack_ptr -= delta;
 
 	return stack_ptr;
@@ -479,8 +479,8 @@ char *z_setup_new_thread(struct k_thread *new_thread,
 	k_obj_core_stats_register(K_OBJ_CORE(new_thread),
 				  &new_thread->base.usage,
 				  sizeof(new_thread->base.usage));
-#endif
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_THREAD */
+#endif /* CONFIG_OBJ_CORE_THREAD */
 
 #ifdef CONFIG_USERSPACE
 	__ASSERT((options & K_USER) == 0U || z_stack_is_user_capable(stack),
@@ -493,7 +493,7 @@ char *z_setup_new_thread(struct k_thread *new_thread,
 
 	/* Any given thread has access to itself */
 	k_object_access_grant(new_thread, new_thread);
-#endif
+#endif /* CONFIG_USERSPACE */
 	z_waitq_init(&new_thread->join_queue);
 
 	/* Initialize various struct k_thread members */
@@ -513,7 +513,7 @@ char *z_setup_new_thread(struct k_thread *new_thread,
 	__ASSERT_NO_MSG(!arch_mem_coherent(stack));
 #endif  /* CONFIG_DYNAMIC_THREAD */
 
-#endif
+#endif /* CONFIG_KERNEL_COHERENCE */
 
 	arch_new_thread(new_thread, stack, stack_ptr, entry, p1, p2, p3);
 
@@ -527,14 +527,14 @@ char *z_setup_new_thread(struct k_thread *new_thread,
 	 */
 	__ASSERT(new_thread->switch_handle != NULL,
 		 "arch layer failed to initialize switch_handle");
-#endif
+#endif /* CONFIG_USE_SWITCH */
 #ifdef CONFIG_THREAD_CUSTOM_DATA
 	/* Initialize custom data field (value is opaque to kernel) */
 	new_thread->custom_data = NULL;
-#endif
+#endif /* CONFIG_THREAD_CUSTOM_DATA */
 #ifdef CONFIG_EVENTS
 	new_thread->no_wake_on_timeout = false;
-#endif
+#endif /* CONFIG_EVENTS */
 #ifdef CONFIG_THREAD_MONITOR
 	new_thread->entry.pEntry = entry;
 	new_thread->entry.parameter1 = p1;
@@ -546,7 +546,7 @@ char *z_setup_new_thread(struct k_thread *new_thread,
 	new_thread->next_thread = _kernel.threads;
 	_kernel.threads = new_thread;
 	k_spin_unlock(&z_thread_monitor_lock, key);
-#endif
+#endif /* CONFIG_THREAD_MONITOR */
 #ifdef CONFIG_THREAD_NAME
 	if (name != NULL) {
 		strncpy(new_thread->name, name,
@@ -556,42 +556,42 @@ char *z_setup_new_thread(struct k_thread *new_thread,
 	} else {
 		new_thread->name[0] = '\0';
 	}
-#endif
+#endif /* CONFIG_THREAD_NAME */
 #ifdef CONFIG_SCHED_CPU_MASK
 	if (IS_ENABLED(CONFIG_SCHED_CPU_MASK_PIN_ONLY)) {
 		new_thread->base.cpu_mask = 1; /* must specify only one cpu */
 	} else {
 		new_thread->base.cpu_mask = -1; /* allow all cpus */
 	}
-#endif
+#endif /* CONFIG_SCHED_CPU_MASK */
 #ifdef CONFIG_ARCH_HAS_CUSTOM_SWAP_TO_MAIN
 	/* _current may be null if the dummy thread is not used */
 	if (!_current) {
 		new_thread->resource_pool = NULL;
 		return stack_ptr;
 	}
-#endif
+#endif /* CONFIG_ARCH_HAS_CUSTOM_SWAP_TO_MAIN */
 #ifdef CONFIG_USERSPACE
 	z_mem_domain_init_thread(new_thread);
 
 	if ((options & K_INHERIT_PERMS) != 0U) {
 		k_thread_perms_inherit(_current, new_thread);
 	}
-#endif
+#endif /* CONFIG_USERSPACE */
 #ifdef CONFIG_SCHED_DEADLINE
 	new_thread->base.prio_deadline = 0;
-#endif
+#endif /* CONFIG_SCHED_DEADLINE */
 	new_thread->resource_pool = _current->resource_pool;
 
 #ifdef CONFIG_SMP
 	z_waitq_init(&new_thread->halt_queue);
-#endif
+#endif /* CONFIG_SMP */
 
 #ifdef CONFIG_SCHED_THREAD_USAGE
 	new_thread->base.usage = (struct k_cycle_stats) {};
 	new_thread->base.usage.track_usage =
 		CONFIG_SCHED_THREAD_USAGE_AUTO_ENABLE;
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE */
 
 	SYS_PORT_TRACING_OBJ_FUNC(k_thread, create, new_thread);
 
@@ -661,7 +661,7 @@ k_tid_t z_vrfy_k_thread_create(struct k_thread *new_thread,
 	stack_obj_size = stack_object->data.stack_data->size;
 #else
 	stack_obj_size = stack_object->data.stack_size;
-#endif
+#endif /* CONFIG_GEN_PRIV_STACKS */
 	K_OOPS(K_SYSCALL_VERIFY_MSG(total_size <= stack_obj_size,
 				    "stack size %zu is too big, max is %zu",
 				    total_size, stack_obj_size));
@@ -707,12 +707,12 @@ void z_init_thread_base(struct _thread_base *thread_base, int priority,
 
 #ifdef CONFIG_SMP
 	thread_base->is_idle = 0;
-#endif
+#endif /* CONFIG_SMP */
 
 #ifdef CONFIG_TIMESLICE_PER_THREAD
 	thread_base->slice_ticks = 0;
 	thread_base->slice_expired = NULL;
-#endif
+#endif /* CONFIG_TIMESLICE_PER_THREAD */
 
 	/* swap_data does not need to be initialized */
 
@@ -731,30 +731,30 @@ FUNC_NORETURN void k_thread_user_mode_enter(k_thread_entry_t entry,
 	_current->entry.parameter1 = p1;
 	_current->entry.parameter2 = p2;
 	_current->entry.parameter3 = p3;
-#endif
+#endif /* CONFIG_THREAD_MONITOR */
 #ifdef CONFIG_USERSPACE
 	__ASSERT(z_stack_is_user_capable(_current->stack_obj),
 		 "dropping to user mode with kernel-only stack object");
 #ifdef CONFIG_THREAD_USERSPACE_LOCAL_DATA
 	memset(_current->userspace_local_data, 0,
 	       sizeof(struct _thread_userspace_local_data));
-#endif
+#endif /* CONFIG_THREAD_USERSPACE_LOCAL_DATA */
 #ifdef CONFIG_THREAD_LOCAL_STORAGE
 	arch_tls_stack_setup(_current,
 			     (char *)(_current->stack_info.start +
 				      _current->stack_info.size));
-#endif
+#endif /* CONFIG_THREAD_LOCAL_STORAGE */
 	arch_user_mode_enter(entry, p1, p2, p3);
 #else
 	/* XXX In this case we do not reset the stack */
 	z_thread_entry(entry, p1, p2, p3);
-#endif
+#endif /* CONFIG_USERSPACE */
 }
 
 #if defined(CONFIG_INIT_STACKS) && defined(CONFIG_THREAD_STACK_INFO)
 #ifdef CONFIG_STACK_GROWS_UP
 #error "Unsupported configuration for stack analysis"
-#endif
+#endif /* CONFIG_STACK_GROWS_UP */
 
 int z_stack_space_get(const uint8_t *stack_start, size_t size, size_t *unused_ptr)
 {
@@ -858,25 +858,25 @@ static inline k_ticks_t z_vrfy_k_thread_timeout_expires_ticks(
 	return z_impl_k_thread_timeout_expires_ticks(thread);
 }
 #include <syscalls/k_thread_timeout_expires_ticks_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 #ifdef CONFIG_INSTRUMENT_THREAD_SWITCHING
 void z_thread_mark_switched_in(void)
 {
 #if defined(CONFIG_SCHED_THREAD_USAGE) && !defined(CONFIG_USE_SWITCH)
 	z_sched_usage_start(_current);
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE && !CONFIG_USE_SWITCH */
 
 #ifdef CONFIG_TRACING
 	SYS_PORT_TRACING_FUNC(k_thread, switched_in);
-#endif
+#endif /* CONFIG_TRACING */
 }
 
 void z_thread_mark_switched_out(void)
 {
 #if defined(CONFIG_SCHED_THREAD_USAGE) && !defined(CONFIG_USE_SWITCH)
 	z_sched_usage_stop();
-#endif
+#endif /*CONFIG_SCHED_THREAD_USAGE && !CONFIG_USE_SWITCH */
 
 #ifdef CONFIG_TRACING
 #ifdef CONFIG_THREAD_LOCAL_STORAGE
@@ -884,9 +884,9 @@ void z_thread_mark_switched_out(void)
 	if (!_current_cpu->current ||
 	    (_current_cpu->current->base.thread_state & _THREAD_DUMMY) != 0)
 		return;
-#endif
+#endif /* CONFIG_THREAD_LOCAL_STORAGE */
 	SYS_PORT_TRACING_FUNC(k_thread, switched_out);
-#endif
+#endif /* CONFIG_TRACING */
 }
 #endif /* CONFIG_INSTRUMENT_THREAD_SWITCHING */
 
@@ -901,7 +901,7 @@ int k_thread_runtime_stats_get(k_tid_t thread,
 	z_sched_thread_usage(thread, stats);
 #else
 	*stats = (k_thread_runtime_stats_t) {};
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE */
 
 	return 0;
 }
@@ -910,7 +910,7 @@ int k_thread_runtime_stats_all_get(k_thread_runtime_stats_t *stats)
 {
 #ifdef CONFIG_SCHED_THREAD_USAGE_ALL
 	k_thread_runtime_stats_t  tmp_stats;
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ALL */
 
 	if (stats == NULL) {
 		return -EINVAL;
@@ -932,10 +932,10 @@ int k_thread_runtime_stats_all_get(k_thread_runtime_stats_t *stats)
 		stats->current_cycles   += tmp_stats.current_cycles;
 		stats->peak_cycles      += tmp_stats.peak_cycles;
 		stats->average_cycles   += tmp_stats.average_cycles;
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ANALYSIS */
 		stats->idle_cycles      += tmp_stats.idle_cycles;
 	}
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ALL */
 
 	return 0;
 }

kernel/timeout.c

@@ -105,7 +105,7 @@ void z_add_timeout(struct _timeout *to, _timeout_func_t fn,
 
 #ifdef CONFIG_KERNEL_COHERENCE
 	__ASSERT_NO_MSG(arch_mem_coherent(to));
-#endif
+#endif /* CONFIG_KERNEL_COHERENCE */
 
 	__ASSERT(!sys_dnode_is_linked(&to->node), "");
 	to->fn = fn;
@@ -255,7 +255,7 @@ void sys_clock_announce(int32_t ticks)
 
 #ifdef CONFIG_TIMESLICING
 	z_time_slice();
-#endif
+#endif /* CONFIG_TIMESLICING */
 }
 
 int64_t sys_clock_tick_get(void)
@@ -274,7 +274,7 @@ uint32_t sys_clock_tick_get_32(void)
 	return (uint32_t)sys_clock_tick_get();
 #else
 	return (uint32_t)curr_tick;
-#endif
+#endif /* CONFIG_TICKLESS_KERNEL */
 }
 
 int64_t z_impl_k_uptime_ticks(void)
@@ -288,7 +288,7 @@ static inline int64_t z_vrfy_k_uptime_ticks(void)
 	return z_impl_k_uptime_ticks();
 }
 #include <syscalls/k_uptime_ticks_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 k_timepoint_t sys_timepoint_calc(k_timeout_t timeout)
 {
@@ -337,4 +337,4 @@ void z_vrfy_sys_clock_tick_set(uint64_t tick)
 {
 	z_impl_sys_clock_tick_set(tick);
 }
-#endif
+#endif /* CONFIG_ZTEST */

kernel/timer.c

@@ -17,7 +17,7 @@ static struct k_spinlock lock;
 
 #ifdef CONFIG_OBJ_CORE_TIMER
 static struct k_obj_type obj_type_timer;
-#endif
+#endif /* CONFIG_OBJ_CORE_TIMER */
 
 /**
  * @brief Handle expiration of a kernel timer object.
@@ -72,7 +72,7 @@ void z_timer_expiration_handler(struct _timeout *t)
 		 * down" behavior on timeout addition).
 		 */
 		next = K_TIMEOUT_ABS_TICKS(k_uptime_ticks() + 1 + next.ticks);
-#endif
+#endif /* CONFIG_TIMEOUT_64BIT */
 		z_add_timeout(&timer->timeout, z_timer_expiration_handler,
 			      next);
 	}
@@ -132,7 +132,7 @@ void k_timer_init(struct k_timer *timer,
 
 #ifdef CONFIG_OBJ_CORE_TIMER
 	k_obj_core_init_and_link(K_OBJ_CORE(timer), &obj_type_timer);
-#endif
+#endif /* CONFIG_OBJ_CORE_TIMER */
 }
 
 
@@ -189,7 +189,7 @@ static inline void z_vrfy_k_timer_start(struct k_timer *timer,
 	z_impl_k_timer_start(timer, duration, period);
 }
 #include <syscalls/k_timer_start_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 void z_impl_k_timer_stop(struct k_timer *timer)
 {
@@ -222,7 +222,7 @@ static inline void z_vrfy_k_timer_stop(struct k_timer *timer)
 	z_impl_k_timer_stop(timer);
 }
 #include <syscalls/k_timer_stop_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 uint32_t z_impl_k_timer_status_get(struct k_timer *timer)
 {
@@ -242,7 +242,7 @@ static inline uint32_t z_vrfy_k_timer_status_get(struct k_timer *timer)
 	return z_impl_k_timer_status_get(timer);
 }
 #include <syscalls/k_timer_status_get_mrsh.c>
-#endif
+#endif /* CONFIG_USERSPACE */
 
 uint32_t z_impl_k_timer_status_sync(struct k_timer *timer)
 {
@@ -342,7 +342,7 @@ static inline void z_vrfy_k_timer_user_data_set(struct k_timer *timer,
 }
 #include <syscalls/k_timer_user_data_set_mrsh.c>
 
-#endif
+#endif /* CONFIG_USERSPACE */
 
 #ifdef CONFIG_OBJ_CORE_TIMER
 static int init_timer_obj_core_list(void)
@@ -362,4 +362,4 @@ static int init_timer_obj_core_list(void)
 }
 SYS_INIT(init_timer_obj_core_list, PRE_KERNEL_1,
 	 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
-#endif
+#endif /* CONFIG_OBJ_CORE_TIMER */

kernel/usage.c

@@ -14,7 +14,7 @@
 /* Need one of these for this to work */
 #if !defined(CONFIG_USE_SWITCH) && !defined(CONFIG_INSTRUMENT_THREAD_SWITCHING)
 #error "No data backend configured for CONFIG_SCHED_THREAD_USAGE"
-#endif
+#endif /* !CONFIG_USE_SWITCH && !CONFIG_INSTRUMENT_THREAD_SWITCHING */
 
 static struct k_spinlock usage_lock;
 
@@ -26,7 +26,7 @@ static uint32_t usage_now(void)
 	now = (uint32_t)timing_counter_get();
 #else
 	now = k_cycle_get_32();
-#endif
+#endif /* CONFIG_THREAD_RUNTIME_STATS_USE_TIMING_FUNCTIONS */
 
 	/* Edge case: we use a zero as a null ("stop() already called") */
 	return (now == 0) ? 1 : now;
@@ -51,12 +51,12 @@ static void sched_cpu_update_usage(struct _cpu *cpu, uint32_t cycles)
 	} else {
 		cpu->usage->current = 0;
 		cpu->usage->num_windows++;
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ANALYSIS */
 	}
 }
 #else
 #define sched_cpu_update_usage(cpu, cycles)   do { } while (0)
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ALL */
 
 static void sched_thread_update_usage(struct k_thread *thread, uint32_t cycles)
 {
@@ -68,7 +68,7 @@ static void sched_thread_update_usage(struct k_thread *thread, uint32_t cycles)
 	if (thread->base.usage.longest < thread->base.usage.current) {
 		thread->base.usage.longest = thread->base.usage.current;
 	}
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ANALYSIS */
 }
 
 void z_sched_usage_start(struct k_thread *thread)
@@ -93,7 +93,7 @@ void z_sched_usage_start(struct k_thread *thread)
 	 */
 
 	_current_cpu->usage0 = usage_now();
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ANALYSIS */
 }
 
 void z_sched_usage_stop(void)
@@ -159,7 +159,7 @@ void z_sched_cpu_usage(uint8_t cpu_id, struct k_thread_runtime_stats *stats)
 		stats->average_cycles = stats->total_cycles /
 					cpu->usage->num_windows;
 	}
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ANALYSIS */
 
 	stats->idle_cycles =
 		_kernel.cpus[cpu_id].idle_thread->base.usage.total;
@@ -168,7 +168,7 @@ void z_sched_cpu_usage(uint8_t cpu_id, struct k_thread_runtime_stats *stats)
 
 	k_spin_unlock(&usage_lock, key);
 }
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ALL */
 
 void z_sched_thread_usage(struct k_thread *thread,
 			  struct k_thread_runtime_stats *stats)
@@ -215,11 +215,11 @@ void z_sched_thread_usage(struct k_thread *thread,
 		stats->average_cycles = stats->total_cycles /
 					thread->base.usage.num_windows;
 	}
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ANALYSIS */
 
 #ifdef CONFIG_SCHED_THREAD_USAGE_ALL
 	stats->idle_cycles = 0;
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ALL */
 	stats->execution_cycles = thread->base.usage.total;
 
 	k_spin_unlock(&usage_lock, key);
@@ -273,7 +273,7 @@ int k_thread_runtime_stats_disable(k_tid_t  thread)
 
 	return 0;
 }
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ANALYSIS */
 
 #ifdef CONFIG_SCHED_THREAD_USAGE_ALL
 void k_sys_runtime_stats_enable(void)
@@ -303,7 +303,7 @@ void k_sys_runtime_stats_enable(void)
 #ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS
 		_kernel.cpus[i].usage->num_windows++;
 		_kernel.cpus[i].usage->current = 0;
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ANALYSIS */
 	}
 
 	k_spin_unlock(&usage_lock, key);
@@ -342,7 +342,7 @@ void k_sys_runtime_stats_disable(void)
 
 	k_spin_unlock(&usage_lock, key);
 }
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ALL */
 
 #ifdef CONFIG_OBJ_CORE_STATS_THREAD
 int z_thread_stats_raw(struct k_obj_core *obj_core, void *stats)
@@ -382,7 +382,7 @@ int z_thread_stats_reset(struct k_obj_core *obj_core)
 	stats->current = 0ULL;
 	stats->longest = 0ULL;
 	stats->num_windows = (thread->base.usage.track_usage) ?  1U : 0U;
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ANALYSIS */
 
 	if (thread != _current_cpu->current) {
 
@@ -423,7 +423,7 @@ int z_thread_stats_disable(struct k_obj_core *obj_core)
 	return k_thread_runtime_stats_disable(thread);
 #else
 	return -ENOTSUP;
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ANALYSIS */
 }
 
 int z_thread_stats_enable(struct k_obj_core *obj_core)
@@ -436,9 +436,9 @@ int z_thread_stats_enable(struct k_obj_core *obj_core)
 	return k_thread_runtime_stats_enable(thread);
 #else
 	return -ENOTSUP;
-#endif
+#endif /* CONFIG_SCHED_THREAD_USAGE_ANALYSIS */
 }
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_THREAD */
 
 #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
 int z_cpu_stats_raw(struct k_obj_core *obj_core, void *stats)
@@ -462,7 +462,7 @@ int z_cpu_stats_query(struct k_obj_core *obj_core, void *stats)
 
 	return 0;
 }
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_SYSTEM */
 
 #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
 int z_kernel_stats_raw(struct k_obj_core *obj_core, void *stats)
@@ -483,4 +483,4 @@ int z_kernel_stats_query(struct k_obj_core *obj_core, void *stats)
 
 	return k_thread_runtime_stats_all_get(stats);
 }
-#endif
+#endif /* CONFIG_OBJ_CORE_STATS_SYSTEM */

kernel/userspace.c

@@ -25,7 +25,7 @@
 
 #ifdef Z_LIBC_PARTITION_EXISTS
 K_APPMEM_PARTITION_DEFINE(z_libc_partition);
-#endif
+#endif /* Z_LIBC_PARTITION_EXISTS */
 
 /* TODO: Find a better place to put this. Since we pull the entire
  * lib..__modules__crypto__mbedtls.a  globals into app shared memory
@@ -33,7 +33,7 @@ K_APPMEM_PARTITION_DEFINE(z_libc_partition);
  */
 #ifdef CONFIG_MBEDTLS
 K_APPMEM_PARTITION_DEFINE(k_mbedtls_partition);
-#endif
+#endif /* CONFIG_MBEDTLS */
 
 #include <zephyr/logging/log.h>
 LOG_MODULE_DECLARE(os, CONFIG_KERNEL_LOG_LEVEL);
@@ -68,14 +68,14 @@ static struct k_spinlock objfree_lock;     /* k_object_free */
 #define STACK_ELEMENT_DATA_SIZE(size) Z_THREAD_STACK_SIZE_ADJUST(size)
 #endif /* CONFIG_GEN_PRIV_STACKS */
 
-#endif
+#endif /* CONFIG_DYNAMIC_OBJECTS */
 static struct k_spinlock obj_lock;         /* kobj struct data */
 
 #define MAX_THREAD_BITS		(CONFIG_MAX_THREAD_BYTES * 8)
 
 #ifdef CONFIG_DYNAMIC_OBJECTS
 extern uint8_t _thread_idx_map[CONFIG_MAX_THREAD_BYTES];
-#endif
+#endif /* CONFIG_DYNAMIC_OBJECTS */
 
 static void clear_perms_cb(struct k_object *ko, void *ctx_ptr);
 
@@ -102,7 +102,7 @@ const char *otype_to_str(enum k_objects otype)
 #else
 	ARG_UNUSED(otype);
 	ret = NULL;
-#endif
+#endif /* CONFIG_LOG */
 	return ret;
 }
 
@@ -147,7 +147,7 @@ uint8_t *z_priv_stack_find(k_thread_stack_t *stack)
 #define DYN_OBJ_DATA_ALIGN_K_THREAD	(ARCH_DYNAMIC_OBJ_K_THREAD_ALIGNMENT)
 #else
 #define DYN_OBJ_DATA_ALIGN_K_THREAD	(sizeof(void *))
-#endif
+#endif /* ARCH_DYNAMIC_OBJ_K_THREAD_ALIGNMENT */
 
 #ifdef CONFIG_DYNAMIC_THREAD_STACK_SIZE
 #ifndef CONFIG_MPU_STACK_GUARD
@@ -211,7 +211,7 @@ static size_t obj_align_get(enum k_objects otype)
 		ret = ARCH_DYNAMIC_OBJ_K_THREAD_ALIGNMENT;
 #else
 		ret = __alignof(struct dyn_obj);
-#endif
+#endif /* ARCH_DYNAMIC_OBJ_K_THREAD_ALIGNMENT */
 		break;
 	default:
 		ret = __alignof(struct dyn_obj);
@@ -349,11 +349,11 @@ static struct k_object *dynamic_object_create(enum k_objects otype, size_t align
 			  Z_THREAD_STACK_OBJ_ALIGN(size));
 #else
 		dyn->kobj.name = dyn->data;
-#endif
+#endif /* CONFIG_ARM_MPU || CONFIG_ARC_MPU */
 #else
 		dyn->kobj.name = dyn->data;
 		dyn->kobj.data.stack_size = adjusted_size;
-#endif
+#endif /* CONFIG_GEN_PRIV_STACKS */
 	} else {
 		dyn->data = z_thread_aligned_alloc(align, obj_size_get(otype) + size);
 		if (dyn->data == NULL) {
@@ -561,7 +561,7 @@ static void unref_check(struct k_object *ko, uintptr_t index)
 	case K_OBJ_PIPE:
 		k_pipe_cleanup((struct k_pipe *)ko->name);
 		break;
-#endif
+#endif /* CONFIG_PIPES */
 	case K_OBJ_MSGQ:
 		k_msgq_cleanup((struct k_msgq *)ko->name);
 		break;
@@ -577,7 +577,7 @@ static void unref_check(struct k_object *ko, uintptr_t index)
 	k_free(dyn->data);
 	k_free(dyn);
 out:
-#endif
+#endif /* CONFIG_DYNAMIC_OBJECTS */
 	k_spin_unlock(&obj_lock, key);
 }
 

kernel/userspace_handler.c

@@ -25,7 +25,7 @@ static struct k_object *validate_kernel_object(const void *obj,
 	if (ret != 0) {
 #ifdef CONFIG_LOG
 		k_object_dump_error(ret, obj, ko, otype);
-#endif
+#endif /* CONFIG_LOG */
 		return NULL;
 	}
 

kernel/work.c

@@ -471,7 +471,7 @@ bool k_work_flush(struct k_work *work,
 	__ASSERT_NO_MSG(sync != NULL);
 #ifdef CONFIG_KERNEL_COHERENCE
 	__ASSERT_NO_MSG(arch_mem_coherent(sync));
-#endif
+#endif /* CONFIG_KERNEL_COHERENCE */
 
 	SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_work, flush, work);
 
@@ -583,7 +583,7 @@ bool k_work_cancel_sync(struct k_work *work,
 	__ASSERT_NO_MSG(!k_is_in_isr());
 #ifdef CONFIG_KERNEL_COHERENCE
 	__ASSERT_NO_MSG(arch_mem_coherent(sync));
-#endif
+#endif /* CONFIG_KERNEL_COHERENCE */
 
 	SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_work, cancel_sync, work, sync);
 
@@ -1066,7 +1066,7 @@ bool k_work_cancel_delayable_sync(struct k_work_delayable *dwork,
 	__ASSERT_NO_MSG(!k_is_in_isr());
 #ifdef CONFIG_KERNEL_COHERENCE
 	__ASSERT_NO_MSG(arch_mem_coherent(sync));
-#endif
+#endif /* CONFIG_KERNEL_COHERENCE */
 
 	SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_work, cancel_delayable_sync, dwork, sync);
 
@@ -1098,7 +1098,7 @@ bool k_work_flush_delayable(struct k_work_delayable *dwork,
 	__ASSERT_NO_MSG(!k_is_in_isr());
 #ifdef CONFIG_KERNEL_COHERENCE
 	__ASSERT_NO_MSG(arch_mem_coherent(sync));
-#endif
+#endif /* CONFIG_KERNEL_COHERENCE */
 
 	SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_work, flush_delayable, dwork, sync);