diff --git a/drivers/virtio/virtio-mmio.c b/drivers/virtio/virtio-mmio.c
index 3fe11edff0c..1c8aacd699b 100644
--- a/drivers/virtio/virtio-mmio.c
+++ b/drivers/virtio/virtio-mmio.c
@@ -344,17 +344,17 @@ static int virtio_mmio_config_virtqueue(FAR struct metal_io_region *io,
       metal_io_write32(io, VIRTIO_MMIO_QUEUE_NUM, vq->vq_nentries);
 
       addr = (uint64_t)((uintptr_t)
-                        kasan_reset_tag((FAR void *)vq->vq_ring.desc));
+                        kasan_clear_tag((FAR void *)vq->vq_ring.desc));
       metal_io_write32(io, VIRTIO_MMIO_QUEUE_DESC_LOW, addr);
       metal_io_write32(io, VIRTIO_MMIO_QUEUE_DESC_HIGH, addr >> 32);
 
       addr = (uint64_t)((uintptr_t)
-                        kasan_reset_tag((FAR void *)vq->vq_ring.avail));
+                        kasan_clear_tag((FAR void *)vq->vq_ring.avail));
       metal_io_write32(io, VIRTIO_MMIO_QUEUE_AVAIL_LOW, addr);
       metal_io_write32(io, VIRTIO_MMIO_QUEUE_AVAIL_HIGH, addr >> 32);
 
       addr = (uint64_t)((uintptr_t)
-                        kasan_reset_tag((FAR void *)vq->vq_ring.used));
+                        kasan_clear_tag((FAR void *)vq->vq_ring.used));
       metal_io_write32(io, VIRTIO_MMIO_QUEUE_USED_LOW, addr);
       metal_io_write32(io, VIRTIO_MMIO_QUEUE_USED_HIGH, addr >> 32);
 
diff --git a/include/nuttx/mm/kasan.h b/include/nuttx/mm/kasan.h
index 5c0e5454be2..a1c4d1745ce 100644
--- a/include/nuttx/mm/kasan.h
+++ b/include/nuttx/mm/kasan.h
@@ -41,7 +41,7 @@
 #  define kasan_unpoison(addr, size) addr
 #  define kasan_register(addr, size)
 #  define kasan_unregister(addr)
-#  define kasan_reset_tag(addr) addr
+#  define kasan_clear_tag(addr) addr
 #  define kasan_start()
 #  define kasan_stop()
 #  define kasan_debugpoint(t,a,s) 0
@@ -133,7 +133,7 @@ void kasan_register(FAR void *addr, FAR size_t *size);
 void kasan_unregister(FAR void *addr);
 
 /****************************************************************************
- * Name: kasan_reset_tag
+ * Name: kasan_clear_tag
  *
  * Input Parameters:
  *   addr - The address of the memory to reset the tag.
@@ -143,7 +143,7 @@ void kasan_unregister(FAR void *addr);
  *
  ****************************************************************************/
 
-FAR void *kasan_reset_tag(FAR const void *addr);
+FAR void *kasan_clear_tag(FAR const void *addr);
 
 /****************************************************************************
  * Name: kasan_start
diff --git a/libs/libc/machine/arm64/arch_elf.c b/libs/libc/machine/arm64/arch_elf.c
index 681012a4428..434864f8748 100644
--- a/libs/libc/machine/arm64/arch_elf.c
+++ b/libs/libc/machine/arm64/arch_elf.c
@@ -184,8 +184,8 @@ aarch64_insn_encode_immediate(enum insn_imm_type_e type,
 static uint64_t do_reloc(enum reloc_op_e op,
                          uintptr_t place, uint64_t val)
 {
-  val = (uint64_t)kasan_reset_tag((const void *)val);
-  place = (uint64_t)kasan_reset_tag((const void *)place);
+  val = (uint64_t)kasan_clear_tag((FAR const void *)val);
+  place = (uint64_t)kasan_clear_tag((FAR const void *)place);
 
   switch (op)
     {
diff --git a/mm/kasan/generic.c b/mm/kasan/generic.c
index b5b6d3ee561..4c3324ad342 100644
--- a/mm/kasan/generic.c
+++ b/mm/kasan/generic.c
@@ -204,7 +204,7 @@ static void kasan_set_poison(FAR const void *addr, size_t size,
  * Public Functions
  ****************************************************************************/
 
-FAR void *kasan_reset_tag(FAR const void *addr)
+FAR void *kasan_clear_tag(FAR const void *addr)
 {
   return (FAR void *)addr;
 }
diff --git a/mm/kasan/sw_tags.c b/mm/kasan/sw_tags.c
index d1ba3bf73a5..0a48209bc0c 100644
--- a/mm/kasan/sw_tags.c
+++ b/mm/kasan/sw_tags.c
@@ -81,7 +81,7 @@ kasan_mem_to_shadow(FAR const void *ptr, size_t size)
   uintptr_t addr;
   int i;
 
-  addr = (uintptr_t)kasan_reset_tag(ptr);
+  addr = (uintptr_t)kasan_clear_tag(ptr);
 
   for (i = 0; i < g_region_count; i++)
     {
@@ -156,7 +156,7 @@ static void kasan_set_poison(FAR const void *addr,
  * Public Functions
  ****************************************************************************/
 
-FAR void *kasan_reset_tag(FAR const void *addr)
+FAR void *kasan_clear_tag(FAR const void *addr)
 {
   return (FAR void *)
          (((uint64_t)(addr)) & ~((uint64_t)0xff << KASAN_TAG_SHIFT));
diff --git a/mm/mempool/mempool_multiple.c b/mm/mempool/mempool_multiple.c
index 30b2928740a..6859518601c 100644
--- a/mm/mempool/mempool_multiple.c
+++ b/mm/mempool/mempool_multiple.c
@@ -309,7 +309,7 @@ mempool_multiple_get_dict(FAR struct mempool_multiple_s *mpool,
     }
 
   addr = (FAR void *)ALIGN_DOWN((uintptr_t)blk, mpool->expandsize);
-  if (kasan_reset_tag(blk) == kasan_reset_tag(addr))
+  if (kasan_clear_tag(blk) == kasan_clear_tag(addr))
     {
       /* It is not a memory block allocated by mempool
        * Because the blk is need not aligned with the expandsize
@@ -328,10 +328,10 @@ mempool_multiple_get_dict(FAR struct mempool_multiple_s *mpool,
   row = index >> mpool->dict_col_num_log2;
   col = index - (row << mpool->dict_col_num_log2);
 
-  addr = kasan_reset_tag(addr);
-  if (kasan_reset_tag(mpool->dict[row]) == NULL ||
-      kasan_reset_tag(mpool->dict[row][col].addr) != addr ||
-      ((FAR char *)kasan_reset_tag(blk) -
+  addr = kasan_clear_tag(addr);
+  if (kasan_clear_tag(mpool->dict[row]) == NULL ||
+      kasan_clear_tag(mpool->dict[row][col].addr) != addr ||
+      ((FAR char *)kasan_clear_tag(blk) -
        (FAR char *)addr >= mpool->dict[row][col].size))
     {
       return NULL;
@@ -630,8 +630,8 @@ int mempool_multiple_free(FAR struct mempool_multiple_s *mpool,
       return -EINVAL;
     }
 
-  blk = (FAR char *)blk - (((FAR char *)kasan_reset_tag(blk) -
-                            ((FAR char *)kasan_reset_tag(dict->addr) +
+  blk = (FAR char *)blk - (((FAR char *)kasan_clear_tag(blk) -
+                            ((FAR char *)kasan_clear_tag(dict->addr) +
                              mpool->minpoolsize)) %
                            MEMPOOL_REALBLOCKSIZE(dict->pool));
   mempool_release(dict->pool, blk);
diff --git a/mm/mm_heap/mm_free.c b/mm/mm_heap/mm_free.c
index b1482ebba58..276b8562dc6 100644
--- a/mm/mm_heap/mm_free.c
+++ b/mm/mm_heap/mm_free.c
@@ -128,7 +128,7 @@ void mm_delayfree(FAR struct mm_heap_s *heap, FAR void *mem, bool delay)
   /* Map the memory chunk into a free node */
 
   node = (FAR struct mm_freenode_s *)
-         ((FAR char *)kasan_reset_tag(mem) - MM_SIZEOF_ALLOCNODE);
+         ((FAR char *)kasan_clear_tag(mem) - MM_SIZEOF_ALLOCNODE);
   nodesize = MM_SIZEOF_NODE(node);
 
   /* Sanity check against double-frees */
diff --git a/mm/mm_heap/mm_heapmember.c b/mm/mm_heap/mm_heapmember.c
index 51d385f6b38..e420ea15afb 100644
--- a/mm/mm_heap/mm_heapmember.c
+++ b/mm/mm_heap/mm_heapmember.c
@@ -57,7 +57,7 @@
 
 bool mm_heapmember(FAR struct mm_heap_s *heap, FAR void *mem)
 {
-  mem = kasan_reset_tag(mem);
+  mem = kasan_clear_tag(mem);
 #if CONFIG_MM_REGIONS > 1
   int i;
 
diff --git a/mm/mm_heap/mm_memalign.c b/mm/mm_heap/mm_memalign.c
index 5d334aaa275..99e976e8782 100644
--- a/mm/mm_heap/mm_memalign.c
+++ b/mm/mm_heap/mm_memalign.c
@@ -142,7 +142,7 @@ FAR void *mm_memalign(FAR struct mm_heap_s *heap, size_t alignment,
   kasan_poison((FAR void *)rawchunk,
                mm_malloc_size(heap, (FAR void *)rawchunk));
 
-  rawchunk = (uintptr_t)kasan_reset_tag((FAR void *)rawchunk);
+  rawchunk = (uintptr_t)kasan_clear_tag((FAR void *)rawchunk);
 
   /* We need to hold the MM mutex while we muck with the chunks and
    * nodelist.
diff --git a/mm/mm_heap/mm_realloc.c b/mm/mm_heap/mm_realloc.c
index 6600290f585..1835c093cc7 100644
--- a/mm/mm_heap/mm_realloc.c
+++ b/mm/mm_heap/mm_realloc.c
@@ -132,7 +132,7 @@ FAR void *mm_realloc(FAR struct mm_heap_s *heap, FAR void *oldmem,
   /* Map the memory chunk into an allocated node structure */
 
   oldnode = (FAR struct mm_allocnode_s *)
-    ((FAR char *)kasan_reset_tag(oldmem) - MM_SIZEOF_ALLOCNODE);
+    ((FAR char *)kasan_clear_tag(oldmem) - MM_SIZEOF_ALLOCNODE);
 
   /* We need to hold the MM mutex while we muck with the nodelist. */