diff --git a/kernel/device.c b/kernel/device.c
index 84600568108..4b6c6d8564b 100644
--- a/kernel/device.c
+++ b/kernel/device.c
@@ -112,7 +112,7 @@ const struct device *z_impl_device_get_binding(const char *name)
 	/* A null string identifies no device.  So does an empty
 	 * string.
 	 */
-	if ((name == NULL) || (*name == 0)) {
+	if ((name == NULL) || (*name == 0U)) {
 		return NULL;
 	}
 
@@ -167,7 +167,7 @@ size_t z_device_get_all_static(struct device const **devices)
 
 bool z_device_ready(const struct device *dev)
 {
-	return dev->state->initialized && (dev->state->init_res == 0);
+	return dev->state->initialized && (dev->state->init_res == 0U);
 }
 
 int device_required_foreach(const struct device *dev,
diff --git a/kernel/include/ksched.h b/kernel/include/ksched.h
index 3caf8f42715..066ab061da5 100644
--- a/kernel/include/ksched.h
+++ b/kernel/include/ksched.h
@@ -250,7 +250,7 @@ static inline void z_sched_lock(void)
 {
 #ifdef CONFIG_PREEMPT_ENABLED
 	__ASSERT(!arch_is_in_isr(), "");
-	__ASSERT(_current->base.sched_locked != 1, "");
+	__ASSERT(_current->base.sched_locked != 1U, "");
 
 	--_current->base.sched_locked;
 
@@ -263,7 +263,7 @@ static ALWAYS_INLINE void z_sched_unlock_no_reschedule(void)
 {
 #ifdef CONFIG_PREEMPT_ENABLED
 	__ASSERT(!arch_is_in_isr(), "");
-	__ASSERT(_current->base.sched_locked != 0, "");
+	__ASSERT(_current->base.sched_locked != 0U, "");
 
 	compiler_barrier();
 
diff --git a/kernel/include/mmu.h b/kernel/include/mmu.h
index f568ec4d04d..50e28394b06 100644
--- a/kernel/include/mmu.h
+++ b/kernel/include/mmu.h
@@ -28,7 +28,7 @@
 #define Z_PHYS_RAM_START	((uintptr_t)CONFIG_SRAM_BASE_ADDRESS)
 #define Z_PHYS_RAM_SIZE		((size_t)KB(CONFIG_SRAM_SIZE))
 #define Z_PHYS_RAM_END		(Z_PHYS_RAM_START + Z_PHYS_RAM_SIZE)
-#define Z_NUM_PAGE_FRAMES	(Z_PHYS_RAM_SIZE / CONFIG_MMU_PAGE_SIZE)
+#define Z_NUM_PAGE_FRAMES	(Z_PHYS_RAM_SIZE / (size_t)CONFIG_MMU_PAGE_SIZE)
 
 /** End virtual address of virtual address space */
 #define Z_VIRT_RAM_START	((uint8_t *)CONFIG_KERNEL_VM_BASE)
@@ -118,27 +118,27 @@ struct z_page_frame {
 
 static inline bool z_page_frame_is_pinned(struct z_page_frame *pf)
 {
-	return (pf->flags & Z_PAGE_FRAME_PINNED) != 0;
+	return (pf->flags & Z_PAGE_FRAME_PINNED) != 0U;
 }
 
 static inline bool z_page_frame_is_reserved(struct z_page_frame *pf)
 {
-	return (pf->flags & Z_PAGE_FRAME_RESERVED) != 0;
+	return (pf->flags & Z_PAGE_FRAME_RESERVED) != 0U;
 }
 
 static inline bool z_page_frame_is_mapped(struct z_page_frame *pf)
 {
-	return (pf->flags & Z_PAGE_FRAME_MAPPED) != 0;
+	return (pf->flags & Z_PAGE_FRAME_MAPPED) != 0U;
 }
 
 static inline bool z_page_frame_is_busy(struct z_page_frame *pf)
 {
-	return (pf->flags & Z_PAGE_FRAME_BUSY) != 0;
+	return (pf->flags & Z_PAGE_FRAME_BUSY) != 0U;
 }
 
 static inline bool z_page_frame_is_backed(struct z_page_frame *pf)
 {
-	return (pf->flags & Z_PAGE_FRAME_BACKED) != 0;
+	return (pf->flags & Z_PAGE_FRAME_BACKED) != 0U;
 }
 
 static inline bool z_page_frame_is_evictable(struct z_page_frame *pf)
@@ -152,12 +152,12 @@ static inline bool z_page_frame_is_evictable(struct z_page_frame *pf)
  */
 static inline bool z_page_frame_is_available(struct z_page_frame *page)
 {
-	return page->flags == 0;
+	return page->flags == 0U;
 }
 
 static inline void z_assert_phys_aligned(uintptr_t phys)
 {
-	__ASSERT(phys % CONFIG_MMU_PAGE_SIZE == 0,
+	__ASSERT(phys % CONFIG_MMU_PAGE_SIZE == 0U,
 		 "physical address 0x%lx is not page-aligned", phys);
 	(void)phys;
 }
@@ -193,9 +193,9 @@ static inline struct z_page_frame *z_phys_to_page_frame(uintptr_t phys)
 
 static inline void z_mem_assert_virtual_region(uint8_t *addr, size_t size)
 {
-	__ASSERT((uintptr_t)addr % CONFIG_MMU_PAGE_SIZE == 0,
+	__ASSERT((uintptr_t)addr % CONFIG_MMU_PAGE_SIZE == 0U,
 		 "unaligned addr %p", addr);
-	__ASSERT(size % CONFIG_MMU_PAGE_SIZE == 0,
+	__ASSERT(size % CONFIG_MMU_PAGE_SIZE == 0U,
 		 "unaligned size %zu", size);
 	__ASSERT(addr + size > addr,
 		 "region %p size %zu zero or wraps around", addr, size);
diff --git a/kernel/init.c b/kernel/init.c
index 042118837df..4605836da5f 100644
--- a/kernel/init.c
+++ b/kernel/init.c
@@ -332,7 +332,7 @@ sys_rand_fallback:
 	 * those devices without a HWRNG entropy driver.
 	 */
 
-	while (length > 0) {
+	while (length > 0U) {
 		uint32_t rndbits;
 		uint8_t *p_rndbits = (uint8_t *)&rndbits;
 
diff --git a/kernel/mailbox.c b/kernel/mailbox.c
index ceb2682139d..7bf7add4030 100644
--- a/kernel/mailbox.c
+++ b/kernel/mailbox.c
@@ -343,7 +343,7 @@ void k_mbox_data_get(struct k_mbox_msg *rx_msg, void *buffer)
 	}
 
 	/* copy message data to buffer, then dispose of message */
-	if ((rx_msg->tx_data != NULL) && (rx_msg->size > 0)) {
+	if ((rx_msg->tx_data != NULL) && (rx_msg->size > 0U)) {
 		(void)memcpy(buffer, rx_msg->tx_data, rx_msg->size);
 	}
 	mbox_message_dispose(rx_msg);
@@ -370,7 +370,7 @@ static int mbox_message_data_check(struct k_mbox_msg *rx_msg, void *buffer)
 	if (buffer != NULL) {
 		/* retrieve data now, then dispose of message */
 		k_mbox_data_get(rx_msg, buffer);
-	} else if (rx_msg->size == 0) {
+	} else if (rx_msg->size == 0U) {
 		/* there is no data to get, so just dispose of message */
 		mbox_message_dispose(rx_msg);
 	} else {
diff --git a/kernel/mem_domain.c b/kernel/mem_domain.c
index 9d8695eb7dd..f3e6f6c74e1 100644
--- a/kernel/mem_domain.c
+++ b/kernel/mem_domain.c
@@ -45,7 +45,7 @@ static bool check_add_partition(struct k_mem_domain *domain,
 	}
 #endif
 
-	if (part->size == 0) {
+	if (part->size == 0U) {
 		LOG_ERR("zero sized partition at %p with base 0x%lx",
 			part, part->start);
 		return false;
@@ -66,7 +66,7 @@ static bool check_add_partition(struct k_mem_domain *domain,
 	for (i = 0; i < domain->num_partitions; i++) {
 		struct k_mem_partition *dpart = &domain->partitions[i];
 
-		if (dpart->size == 0) {
+		if (dpart->size == 0U) {
 			/* Unused slot */
 			continue;
 		}
diff --git a/kernel/mem_slab.c b/kernel/mem_slab.c
index bc2e45bcd26..cc2d3c68ca9 100644
--- a/kernel/mem_slab.c
+++ b/kernel/mem_slab.c
@@ -36,7 +36,7 @@ static int create_free_list(struct k_mem_slab *slab)
 
 	/* blocks must be word aligned */
 	CHECKIF(((slab->block_size | (uintptr_t)slab->buffer) &
-				(sizeof(void *) - 1)) != 0) {
+				(sizeof(void *) - 1)) != 0U) {
 		return -EINVAL;
 	}
 
diff --git a/kernel/mmu.c b/kernel/mmu.c
index e48a8d85cd6..b03f63cb26a 100644
--- a/kernel/mmu.c
+++ b/kernel/mmu.c
@@ -293,8 +293,8 @@ static int map_anon_page(void *addr, uint32_t flags)
 {
 	struct z_page_frame *pf;
 	uintptr_t phys;
-	bool lock = (flags & K_MEM_MAP_LOCK) != 0;
-	bool uninit = (flags & K_MEM_MAP_UNINIT) != 0;
+	bool lock = (flags & K_MEM_MAP_LOCK) != 0U;
+	bool uninit = (flags & K_MEM_MAP_UNINIT) != 0U;
 
 	pf = free_page_frame_list_get();
 	if (pf == NULL) {
@@ -346,17 +346,17 @@ void *k_mem_map(size_t size, uint32_t flags)
 	size_t total_size = size;
 	int ret;
 	k_spinlock_key_t key;
-	bool guard = (flags & K_MEM_MAP_GUARD) != 0;
+	bool guard = (flags & K_MEM_MAP_GUARD) != 0U;
 	uint8_t *pos;
 
-	__ASSERT(!(((flags & K_MEM_PERM_USER) != 0) &&
-		   ((flags & K_MEM_MAP_UNINIT) != 0)),
+	__ASSERT(!(((flags & K_MEM_PERM_USER) != 0U) &&
+		   ((flags & K_MEM_MAP_UNINIT) != 0U)),
 		 "user access to anonymous uninitialized pages is forbidden");
-	__ASSERT(size % CONFIG_MMU_PAGE_SIZE == 0,
+	__ASSERT(size % CONFIG_MMU_PAGE_SIZE == 0U,
 		 "unaligned size %zu passed to %s", size, __func__);
 	__ASSERT(size != 0, "zero sized memory mapping");
 	__ASSERT(page_frames_initialized, "%s called too early", __func__);
-	__ASSERT((flags & K_MEM_CACHE_MASK) == 0,
+	__ASSERT((flags & K_MEM_CACHE_MASK) == 0U,
 		 "%s does not support explicit cache settings", __func__);
 
 	key = k_spin_lock(&z_mm_lock);
@@ -406,7 +406,7 @@ size_t k_mem_free_get(void)
 	ret = z_free_page_count;
 	k_spin_unlock(&z_mm_lock, key);
 
-	return ret * CONFIG_MMU_PAGE_SIZE;
+	return ret * (size_t)CONFIG_MMU_PAGE_SIZE;
 }
 
 /* This may be called from arch early boot code before z_cstart() is invoked.
@@ -423,7 +423,7 @@ void z_phys_map(uint8_t **virt_ptr, uintptr_t phys, size_t size, uint32_t flags)
 	addr_offset = k_mem_region_align(&aligned_phys, &aligned_size,
 					 phys, size,
 					 CONFIG_MMU_PAGE_SIZE);
-	__ASSERT(aligned_size != 0, "0-length mapping at 0x%lx", aligned_phys);
+	__ASSERT(aligned_size != 0U, "0-length mapping at 0x%lx", aligned_phys);
 	__ASSERT(aligned_phys < (aligned_phys + (aligned_size - 1)),
 		 "wraparound for physical address 0x%lx (size %zu)",
 		 aligned_phys, aligned_size);
@@ -497,7 +497,7 @@ void z_kernel_map_fixup(void)
 				      CONFIG_MMU_PAGE_SIZE);
 	size_t kobject_size = (size_t)(Z_KERNEL_VIRT_END - kobject_page_begin);
 
-	if (kobject_size != 0) {
+	if (kobject_size != 0U) {
 		arch_mem_map(kobject_page_begin,
 			     Z_BOOT_VIRT_TO_PHYS(kobject_page_begin),
 			     kobject_size, K_MEM_PERM_RW | K_MEM_CACHE_WB);
diff --git a/kernel/msg_q.c b/kernel/msg_q.c
index 7a248f0469a..87e981a6a51 100644
--- a/kernel/msg_q.c
+++ b/kernel/msg_q.c
@@ -105,7 +105,7 @@ int k_msgq_cleanup(struct k_msgq *msgq)
 		return -EBUSY;
 	}
 
-	if ((msgq->flags & K_MSGQ_FLAG_ALLOC) != 0) {
+	if ((msgq->flags & K_MSGQ_FLAG_ALLOC) != 0U) {
 		k_free(msgq->buffer_start);
 		msgq->flags &= ~K_MSGQ_FLAG_ALLOC;
 	}
@@ -199,7 +199,7 @@ int z_impl_k_msgq_get(struct k_msgq *msgq, void *data, k_timeout_t timeout)
 
 	key = k_spin_lock(&msgq->lock);
 
-	if (msgq->used_msgs > 0) {
+	if (msgq->used_msgs > 0U) {
 		/* take first available message from queue */
 		(void)memcpy(data, msgq->read_ptr, msgq->msg_size);
 		msgq->read_ptr += msgq->msg_size;
@@ -260,7 +260,7 @@ int z_impl_k_msgq_peek(struct k_msgq *msgq, void *data)
 
 	key = k_spin_lock(&msgq->lock);
 
-	if (msgq->used_msgs > 0) {
+	if (msgq->used_msgs > 0U) {
 		/* take first available message from queue */
 		(void)memcpy(data, msgq->read_ptr, msgq->msg_size);
 		result = 0;
diff --git a/kernel/pipes.c b/kernel/pipes.c
index 9f4cd11e4b2..663845fa063 100644
--- a/kernel/pipes.c
+++ b/kernel/pipes.c
@@ -116,7 +116,7 @@ int z_impl_k_pipe_alloc_init(struct k_pipe *pipe, size_t size)
 	void *buffer;
 	int ret;
 
-	if (size != 0) {
+	if (size != 0U) {
 		buffer = z_thread_malloc(size);
 		if (buffer != NULL) {
 			k_pipe_init(pipe, buffer, size);
@@ -150,7 +150,7 @@ int k_pipe_cleanup(struct k_pipe *pipe)
 		return -EAGAIN;
 	}
 
-	if ((pipe->flags & K_PIPE_FLAG_ALLOC) != 0) {
+	if ((pipe->flags & K_PIPE_FLAG_ALLOC) != 0U) {
 		k_free(pipe->buffer);
 		pipe->buffer = NULL;
 		pipe->flags &= ~K_PIPE_FLAG_ALLOC;
@@ -493,7 +493,7 @@ int z_pipe_put_internal(struct k_pipe *pipe, struct k_pipe_async *async_desc,
 
 	if (!K_TIMEOUT_EQ(timeout, K_NO_WAIT)
 	    && num_bytes_written >= min_xfer
-	    && min_xfer > 0) {
+	    && min_xfer > 0U) {
 		*bytes_written = num_bytes_written;
 		k_sched_unlock();
 		return 0;
@@ -647,7 +647,7 @@ int z_impl_k_pipe_get(struct k_pipe *pipe, void *data, size_t bytes_to_read,
 
 	if (!K_TIMEOUT_EQ(timeout, K_NO_WAIT)
 	    && num_bytes_read >= min_xfer
-	    && min_xfer > 0) {
+	    && min_xfer > 0U) {
 		k_sched_unlock();
 
 		*bytes_read = num_bytes_read;
@@ -725,7 +725,7 @@ size_t z_impl_k_pipe_read_avail(struct k_pipe *pipe)
 	k_spinlock_key_t key;
 
 	/* Buffer and size are fixed. No need to spin. */
-	if (pipe->buffer == NULL || pipe->size == 0) {
+	if (pipe->buffer == NULL || pipe->size == 0U) {
 		res = 0;
 		goto out;
 	}
@@ -762,7 +762,7 @@ size_t z_impl_k_pipe_write_avail(struct k_pipe *pipe)
 	k_spinlock_key_t key;
 
 	/* Buffer and size are fixed. No need to spin. */
-	if (pipe->buffer == NULL || pipe->size == 0) {
+	if (pipe->buffer == NULL || pipe->size == 0U) {
 		res = 0;
 		goto out;
 	}
diff --git a/kernel/poll.c b/kernel/poll.c
index f9e0eef679d..56886db0aab 100644
--- a/kernel/poll.c
+++ b/kernel/poll.c
@@ -316,7 +316,7 @@ static inline int z_vrfy_k_poll(struct k_poll_event *events,
 	/* Validate the events buffer and make a copy of it in an
 	 * allocated kernel-side buffer.
 	 */
-	if (Z_SYSCALL_VERIFY(num_events >= 0)) {
+	if (Z_SYSCALL_VERIFY(num_events >= 0U)) {
 		ret = -EINVAL;
 		goto out;
 	}
diff --git a/kernel/sched.c b/kernel/sched.c
index 99d76887a10..b2dc3ce89de 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -235,7 +235,7 @@ void z_requeue_current(struct k_thread *curr)
 
 static inline bool is_aborting(struct k_thread *thread)
 {
-	return (thread->base.thread_state & _THREAD_ABORTING) != 0;
+	return (thread->base.thread_state & _THREAD_ABORTING) != 0U;
 }
 
 static ALWAYS_INLINE struct k_thread *next_up(void)
@@ -776,7 +776,7 @@ void z_thread_priority_set(struct k_thread *thread, int prio)
 	arch_sched_ipi();
 #endif
 
-	if (need_sched && _current->base.sched_locked == 0) {
+	if (need_sched && _current->base.sched_locked == 0U) {
 		z_reschedule_unlocked();
 	}
 }
@@ -837,7 +837,7 @@ void k_sched_unlock(void)
 {
 #ifdef CONFIG_PREEMPT_ENABLED
 	LOCKED(&sched_spinlock) {
-		__ASSERT(_current->base.sched_locked != 0, "");
+		__ASSERT(_current->base.sched_locked != 0U, "");
 		__ASSERT(!arch_is_in_isr(), "");
 
 		++_current->base.sched_locked;
@@ -1452,7 +1452,7 @@ static void end_thread(struct k_thread *thread)
 	/* We hold the lock, and the thread is known not to be running
 	 * anywhere.
 	 */
-	if ((thread->base.thread_state & _THREAD_DEAD) == 0) {
+	if ((thread->base.thread_state & _THREAD_DEAD) == 0U) {
 		thread->base.thread_state |= _THREAD_DEAD;
 		thread->base.thread_state &= ~_THREAD_ABORTING;
 		if (z_is_thread_queued(thread)) {
diff --git a/kernel/thread.c b/kernel/thread.c
index 3e2d2e6e197..025eed95a9f 100644
--- a/kernel/thread.c
+++ b/kernel/thread.c
@@ -123,7 +123,7 @@ bool z_is_thread_essential(void)
 #ifdef CONFIG_SYS_CLOCK_EXISTS
 void z_impl_k_busy_wait(uint32_t usec_to_wait)
 {
-	if (usec_to_wait == 0) {
+	if (usec_to_wait == 0U) {
 		return;
 	}
 
diff --git a/kernel/userspace.c b/kernel/userspace.c
index 90fc6db8984..f8f39a08ebd 100644
--- a/kernel/userspace.c
+++ b/kernel/userspace.c
@@ -806,7 +806,7 @@ char *z_user_string_alloc_copy(const char *src, size_t maxlen)
 	 * properly.
 	 */
 	if (ret != NULL) {
-		ret[actual_len - 1] = '\0';
+		ret[actual_len - 1U] = '\0';
 	}
 out:
 	return ret;
diff --git a/kernel/work.c b/kernel/work.c
index 58f5b26a171..1e31a9e7772 100644
--- a/kernel/work.c
+++ b/kernel/work.c
@@ -395,7 +395,7 @@ static bool work_flush_locked(struct k_work *work,
 			      struct z_work_flusher *flusher)
 {
 	bool need_flush = (flags_get(&work->flags)
-			   & (K_WORK_QUEUED | K_WORK_RUNNING)) != 0;
+			   & (K_WORK_QUEUED | K_WORK_RUNNING)) != 0U;
 
 	if (need_flush) {
 		struct k_work_q *queue = work->queue;