diff --git a/arch/8051/src/up_idle.c b/arch/8051/src/up_idle.c
index 4259f8a74b7..e06046c0cdb 100644
--- a/arch/8051/src/up_idle.c
+++ b/arch/8051/src/up_idle.c
@@ -1,4 +1,4 @@
-/************************************************************
+/************************************************************************
  * up_idle.c
  *
  *   Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved.
@@ -33,7 +33,7 @@
  *
  ************************************************************************/
 
-/************************************************************
+/************************************************************************
  * Included Files
  ************************************************************************/
 
@@ -44,27 +44,27 @@
 
 #include "up_internal.h"
 
-/************************************************************
- * Private Definitions
+/************************************************************************
+ * Pre-processor Definitions
  ************************************************************************/
 
-/************************************************************
+/************************************************************************
  * Private Data
  ************************************************************************/
 
 #if defined(CONFIG_ARCH_LEDS) && defined(CONFIG_ARCH_BRINGUP)
-static /**************** g_ledtoggle = 0;
+static uint8_t g_ledtoggle = 0;
 #endif
 
-/************************************************************
+/************************************************************************
  * Private Functions
  ************************************************************************/
 
-/************************************************************
+/************************************************************************
  * Public Functions
  ************************************************************************/
 
-/************************************************************
+/************************************************************************
  * Name: up_idle
  *
  * Description:
@@ -93,4 +93,3 @@ void up_idle(void)
     }
 #endif
 }
-
diff --git a/arch/arm/src/common/up_createstack.c b/arch/arm/src/common/up_createstack.c
index b17e13b5b87..efa0e0a1576 100644
--- a/arch/arm/src/common/up_createstack.c
+++ b/arch/arm/src/common/up_createstack.c
@@ -136,7 +136,7 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
     {
       /* Yes.. free it */
 
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
       tcb->stack_alloc_ptr = NULL;
     }
 
@@ -149,9 +149,9 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
        */
 
 #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK)
-      tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size);
+      tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size);
 #else
-      tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size);
+      tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size);
 #endif
 #ifdef CONFIG_DEBUG
       if (!tcb->stack_alloc_ptr)
diff --git a/arch/arm/src/common/up_releasestack.c b/arch/arm/src/common/up_releasestack.c
index cb0bf030ade..94311b20c31 100644
--- a/arch/arm/src/common/up_releasestack.c
+++ b/arch/arm/src/common/up_releasestack.c
@@ -71,7 +71,7 @@ void up_release_stack(struct tcb_s *dtcb)
 {
   if (dtcb->stack_alloc_ptr)
     {
-      sched_free(dtcb->stack_alloc_ptr);
+      sched_ufree(dtcb->stack_alloc_ptr);
       dtcb->stack_alloc_ptr = NULL;
     }
 
diff --git a/arch/arm/src/common/up_usestack.c b/arch/arm/src/common/up_usestack.c
index d94f99a5756..57eb1d36ea9 100644
--- a/arch/arm/src/common/up_usestack.c
+++ b/arch/arm/src/common/up_usestack.c
@@ -116,7 +116,7 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size)
 
   if (tcb->stack_alloc_ptr)
     {
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
     }
 
   /* Save the stack allocation */
diff --git a/arch/avr/src/avr/up_createstack.c b/arch/avr/src/avr/up_createstack.c
index aed449f8234..1eb56f918e1 100644
--- a/arch/avr/src/avr/up_createstack.c
+++ b/arch/avr/src/avr/up_createstack.c
@@ -95,7 +95,7 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
     {
       /* Yes.. free it */
 
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
       tcb->stack_alloc_ptr = NULL;
     }
 
@@ -108,9 +108,9 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
        */
 
 #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK)
-      tcb->stack_alloc_ptr = (FAR void *)kzalloc(stack_size);
+      tcb->stack_alloc_ptr = (FAR void *)kuzalloc(stack_size);
 #else
-      tcb->stack_alloc_ptr = (FAR void *)kmalloc(stack_size);
+      tcb->stack_alloc_ptr = (FAR void *)kumalloc(stack_size);
 #endif
 #ifdef CONFIG_DEBUG
       if (!tcb->stack_alloc_ptr)
diff --git a/arch/avr/src/avr/up_usestack.c b/arch/avr/src/avr/up_usestack.c
index cd93f5d23c3..22bdcf84e1c 100644
--- a/arch/avr/src/avr/up_usestack.c
+++ b/arch/avr/src/avr/up_usestack.c
@@ -92,7 +92,7 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size)
     {
       /* Yes.. free it */
 
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
     }
 
   /* Save the stack allocation */
diff --git a/arch/avr/src/avr32/up_createstack.c b/arch/avr/src/avr32/up_createstack.c
index bfe87743f39..5d49f497786 100644
--- a/arch/avr/src/avr32/up_createstack.c
+++ b/arch/avr/src/avr32/up_createstack.c
@@ -94,7 +94,7 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
     {
       /* Yes.. free it */
 
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
       tcb->stack_alloc_ptr = NULL;
     }
 
@@ -107,9 +107,9 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
        */
 
 #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK)
-      tcb->stack_alloc_ptr = (FAR void *)kzalloc(stack_size);
+      tcb->stack_alloc_ptr = (FAR void *)kuzalloc(stack_size);
 #else
-      tcb->stack_alloc_ptr = (FAR void *)kmalloc(stack_size);
+      tcb->stack_alloc_ptr = (FAR void *)kumalloc(stack_size);
 #endif
 #ifdef CONFIG_DEBUG
       if (!tcb->stack_alloc_ptr)
diff --git a/arch/avr/src/avr32/up_usestack.c b/arch/avr/src/avr32/up_usestack.c
index 5afadb922d8..43dc6bfe9c0 100644
--- a/arch/avr/src/avr32/up_usestack.c
+++ b/arch/avr/src/avr32/up_usestack.c
@@ -89,7 +89,7 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size)
 
   if (tcb->stack_alloc_ptr)
     {
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
     }
 
   /* Save the stack allocation */
diff --git a/arch/avr/src/common/up_releasestack.c b/arch/avr/src/common/up_releasestack.c
index 98b1faea104..afce3261db2 100644
--- a/arch/avr/src/common/up_releasestack.c
+++ b/arch/avr/src/common/up_releasestack.c
@@ -71,7 +71,7 @@ void up_release_stack(struct tcb_s *dtcb)
 {
   if (dtcb->stack_alloc_ptr)
     {
-      sched_free(dtcb->stack_alloc_ptr);
+      sched_ufree(dtcb->stack_alloc_ptr);
       dtcb->stack_alloc_ptr = NULL;
     }
 
diff --git a/arch/hc/src/common/up_createstack.c b/arch/hc/src/common/up_createstack.c
index 272c4e849fa..d5d5a853a66 100644
--- a/arch/hc/src/common/up_createstack.c
+++ b/arch/hc/src/common/up_createstack.c
@@ -91,7 +91,7 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
     {
       /* Yes.. free it */
 
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
       tcb->stack_alloc_ptr = NULL;
     }
 
@@ -104,9 +104,9 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
        */
 
 #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK)
-      tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size);
+      tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size);
 #else
-      tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size);
+      tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size);
 #endif
 #ifdef CONFIG_DEBUG
       if (!tcb->stack_alloc_ptr)
diff --git a/arch/hc/src/common/up_releasestack.c b/arch/hc/src/common/up_releasestack.c
index 3d8b6117688..f6eaec982fc 100644
--- a/arch/hc/src/common/up_releasestack.c
+++ b/arch/hc/src/common/up_releasestack.c
@@ -72,7 +72,7 @@ void up_release_stack(struct tcb_s *dtcb)
 {
   if (dtcb->stack_alloc_ptr)
     {
-      sched_free(dtcb->stack_alloc_ptr);
+      sched_ufree(dtcb->stack_alloc_ptr);
       dtcb->stack_alloc_ptr = NULL;
     }
 
diff --git a/arch/hc/src/common/up_usestack.c b/arch/hc/src/common/up_usestack.c
index 53a571ed4ba..f23677be529 100644
--- a/arch/hc/src/common/up_usestack.c
+++ b/arch/hc/src/common/up_usestack.c
@@ -87,7 +87,7 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size)
 
   if (tcb->stack_alloc_ptr && tcb->adj_stack_size != stack_size)
     {
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
       tcb->stack_alloc_ptr = NULL;
     }
 
diff --git a/arch/mips/src/common/up_createstack.c b/arch/mips/src/common/up_createstack.c
index 02cdd83d721..e4689fc7c9a 100644
--- a/arch/mips/src/common/up_createstack.c
+++ b/arch/mips/src/common/up_createstack.c
@@ -112,7 +112,7 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
     {
       /* Yes.. free it */
 
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
       tcb->stack_alloc_ptr = NULL;
     }
 
@@ -125,9 +125,9 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
        */
 
 #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK)
-      tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size);
+      tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size);
 #else
-      tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size);
+      tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size);
 #endif
 #ifdef CONFIG_DEBUG
       if (!tcb->stack_alloc_ptr)
diff --git a/arch/mips/src/common/up_releasestack.c b/arch/mips/src/common/up_releasestack.c
index 7cbeb86e7e2..d507c3b7b47 100644
--- a/arch/mips/src/common/up_releasestack.c
+++ b/arch/mips/src/common/up_releasestack.c
@@ -71,7 +71,7 @@ void up_release_stack(struct tcb_s *dtcb)
 {
   if (dtcb->stack_alloc_ptr)
     {
-      sched_free(dtcb->stack_alloc_ptr);
+      sched_ufree(dtcb->stack_alloc_ptr);
       dtcb->stack_alloc_ptr = NULL;
     }
 
diff --git a/arch/mips/src/common/up_usestack.c b/arch/mips/src/common/up_usestack.c
index 6fa521579e0..208c15bc04d 100644
--- a/arch/mips/src/common/up_usestack.c
+++ b/arch/mips/src/common/up_usestack.c
@@ -89,7 +89,7 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size)
 
   if (tcb->stack_alloc_ptr)
     {
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
     }
 
   /* Save the stack allocation */
diff --git a/arch/rgmp/src/nuttx.c b/arch/rgmp/src/nuttx.c
index 63e925b8cfb..0a13401c20c 100644
--- a/arch/rgmp/src/nuttx.c
+++ b/arch/rgmp/src/nuttx.c
@@ -123,7 +123,7 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
 
     /* Allocate the memory for the stack */
 
-    uint32_t *stack_alloc_ptr = (uint32_t*)kmalloc(adj_stack_size);
+    uint32_t *stack_alloc_ptr = (uint32_t*)kumalloc(adj_stack_size);
     if (stack_alloc_ptr) {
 		/* This is the address of the last word in the allocation */
 
@@ -161,7 +161,7 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size)
 void up_release_stack(struct tcb_s *dtcb)
 {
     if (dtcb->stack_alloc_ptr) {
-		kfree(dtcb->stack_alloc_ptr);
+		kufree(dtcb->stack_alloc_ptr);
     }
 
     dtcb->stack_alloc_ptr = NULL;
diff --git a/arch/sh/src/common/up_createstack.c b/arch/sh/src/common/up_createstack.c
index 296245a4943..9abc05f76da 100644
--- a/arch/sh/src/common/up_createstack.c
+++ b/arch/sh/src/common/up_createstack.c
@@ -91,7 +91,7 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
     {
       /* Yes.. free it */
 
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
       tcb->stack_alloc_ptr = NULL;
     }
 
@@ -104,9 +104,9 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
        */
 
 #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK)
-      tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size);
+      tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size);
 #else
-      tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size);
+      tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size);
 #endif
 #ifdef CONFIG_DEBUG
       if (!tcb->stack_alloc_ptr)
diff --git a/arch/sh/src/common/up_releasestack.c b/arch/sh/src/common/up_releasestack.c
index 3b4e4c91436..a8b9d7769da 100644
--- a/arch/sh/src/common/up_releasestack.c
+++ b/arch/sh/src/common/up_releasestack.c
@@ -71,7 +71,7 @@ void up_release_stack(struct tcb_s *dtcb)
 {
   if (dtcb->stack_alloc_ptr)
     {
-      sched_free(dtcb->stack_alloc_ptr);
+      sched_ufree(dtcb->stack_alloc_ptr);
       dtcb->stack_alloc_ptr = NULL;
     }
 
diff --git a/arch/sh/src/common/up_usestack.c b/arch/sh/src/common/up_usestack.c
index ee26cb70c9b..1cc383a91db 100644
--- a/arch/sh/src/common/up_usestack.c
+++ b/arch/sh/src/common/up_usestack.c
@@ -89,7 +89,7 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size)
 
   if (tcb->stack_alloc_ptr)
     {
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
     }
 
   /* Save the stack allocation */
diff --git a/arch/sim/src/up_createstack.c b/arch/sim/src/up_createstack.c
index fb7e8008112..a6ebcc5fa00 100644
--- a/arch/sim/src/up_createstack.c
+++ b/arch/sim/src/up_createstack.c
@@ -96,7 +96,7 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
 
   /* Allocate the memory for the stack */
 
-  uint32_t *stack_alloc_ptr = (uint32_t*)kmalloc(adj_stack_size);
+  uint32_t *stack_alloc_ptr = (uint32_t*)kumalloc(adj_stack_size);
   if (stack_alloc_ptr)
     {
       /* This is the address of the last word in the allocation */
diff --git a/arch/x86/src/i486/up_createstack.c b/arch/x86/src/i486/up_createstack.c
index 62a763b3094..927abcf2e23 100644
--- a/arch/x86/src/i486/up_createstack.c
+++ b/arch/x86/src/i486/up_createstack.c
@@ -93,7 +93,7 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
     {
       /* Yes.. free it */
 
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
       tcb->stack_alloc_ptr = NULL;
     }
 
@@ -106,9 +106,9 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
        */
 
 #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK)
-      tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size);
+      tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size);
 #else
-      tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size);
+      tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size);
 #endif
 #ifdef CONFIG_DEBUG
       if (!tcb->stack_alloc_ptr)
diff --git a/arch/x86/src/i486/up_releasestack.c b/arch/x86/src/i486/up_releasestack.c
index 47b3ea994dd..38a2dbfe81b 100644
--- a/arch/x86/src/i486/up_releasestack.c
+++ b/arch/x86/src/i486/up_releasestack.c
@@ -71,7 +71,7 @@ void up_release_stack(struct tcb_s *dtcb)
 {
   if (dtcb->stack_alloc_ptr)
     {
-      sched_free(dtcb->stack_alloc_ptr);
+      sched_ufree(dtcb->stack_alloc_ptr);
       dtcb->stack_alloc_ptr = NULL;
     }
 
diff --git a/arch/x86/src/i486/up_usestack.c b/arch/x86/src/i486/up_usestack.c
index 38290dd777f..8865a9e3fc1 100644
--- a/arch/x86/src/i486/up_usestack.c
+++ b/arch/x86/src/i486/up_usestack.c
@@ -88,7 +88,7 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size)
 
   if (tcb->stack_alloc_ptr)
     {
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
     }
 
   /* Save the stack allocation */
diff --git a/arch/z16/src/common/up_createstack.c b/arch/z16/src/common/up_createstack.c
index b2deb4bf015..fcbf90bfec5 100644
--- a/arch/z16/src/common/up_createstack.c
+++ b/arch/z16/src/common/up_createstack.c
@@ -92,7 +92,7 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
     {
       /* Yes.. free it */
 
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
       tcb->stack_alloc_ptr = NULL;
     }
 
@@ -105,9 +105,9 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
        */
 
 #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK)
-      tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size);
+      tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size);
 #else
-      tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size);
+      tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size);
 #endif
 #ifdef CONFIG_DEBUG
       if (!tcb->stack_alloc_ptr)
diff --git a/arch/z16/src/common/up_releasestack.c b/arch/z16/src/common/up_releasestack.c
index 82ba1b122b5..f6618692588 100644
--- a/arch/z16/src/common/up_releasestack.c
+++ b/arch/z16/src/common/up_releasestack.c
@@ -71,7 +71,7 @@ void up_release_stack(struct tcb_s *dtcb)
 {
   if (dtcb->stack_alloc_ptr)
     {
-      sched_free(dtcb->stack_alloc_ptr);
+      sched_ufree(dtcb->stack_alloc_ptr);
       dtcb->stack_alloc_ptr = NULL;
     }
 
diff --git a/arch/z16/src/common/up_usestack.c b/arch/z16/src/common/up_usestack.c
index 9ebe01de4a3..671930bbeb7 100644
--- a/arch/z16/src/common/up_usestack.c
+++ b/arch/z16/src/common/up_usestack.c
@@ -89,7 +89,7 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size)
 
   if (tcb->stack_alloc_ptr)
     {
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
     }
 
   /* Save the stack allocation */
diff --git a/arch/z80/src/common/up_createstack.c b/arch/z80/src/common/up_createstack.c
index c00f5f0715b..c086839bf20 100644
--- a/arch/z80/src/common/up_createstack.c
+++ b/arch/z80/src/common/up_createstack.c
@@ -91,7 +91,7 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
     {
       /* Yes.. free it */
 
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
       tcb->stack_alloc_ptr = NULL;
     }
 
@@ -104,9 +104,9 @@ int up_create_stack(struct tcb_s *tcb, size_t stack_size)
        */
 
 #if defined(CONFIG_DEBUG) && !defined(CONFIG_DEBUG_STACK)
-      tcb->stack_alloc_ptr = (uint32_t *)kzalloc(stack_size);
+      tcb->stack_alloc_ptr = (uint32_t *)kuzalloc(stack_size);
 #else
-      tcb->stack_alloc_ptr = (uint32_t *)kmalloc(stack_size);
+      tcb->stack_alloc_ptr = (uint32_t *)kumalloc(stack_size);
 #endif
 #ifdef CONFIG_DEBUG
       if (!tcb->stack_alloc_ptr)
diff --git a/arch/z80/src/common/up_releasestack.c b/arch/z80/src/common/up_releasestack.c
index b5c9ef2f9da..346971610a7 100644
--- a/arch/z80/src/common/up_releasestack.c
+++ b/arch/z80/src/common/up_releasestack.c
@@ -71,7 +71,7 @@ void up_release_stack(struct tcb_s *dtcb)
 {
   if (dtcb->stack_alloc_ptr)
     {
-      sched_free(dtcb->stack_alloc_ptr);
+      sched_ufree(dtcb->stack_alloc_ptr);
       dtcb->stack_alloc_ptr = NULL;
     }
 
diff --git a/arch/z80/src/common/up_usestack.c b/arch/z80/src/common/up_usestack.c
index 0aaa5f906e3..f6fdb5fd46e 100644
--- a/arch/z80/src/common/up_usestack.c
+++ b/arch/z80/src/common/up_usestack.c
@@ -88,7 +88,7 @@ int up_use_stack(struct tcb_s *tcb, void *stack, size_t stack_size)
 
   if (tcb->stack_alloc_ptr)
     {
-      sched_free(tcb->stack_alloc_ptr);
+      sched_ufree(tcb->stack_alloc_ptr);
     }
 
   /* Save the stack allocation */
diff --git a/drivers/usbhost/usbhost_skeleton.c b/drivers/usbhost/usbhost_skeleton.c
index c44a265e808..bc30eedd7c2 100644
--- a/drivers/usbhost/usbhost_skeleton.c
+++ b/drivers/usbhost/usbhost_skeleton.c
@@ -276,7 +276,7 @@ static inline void usbhost_freeclass(FAR struct usbhost_state_s *class)
 {
   DEBUGASSERT(class != NULL);
 
-  /* Free the class instance (perhaps calling sched_free() in case we are
+  /* Free the class instance (perhaps calling sched_kfree() in case we are
    * executing from an interrupt handler.
    */
 
diff --git a/drivers/usbhost/usbhost_storage.c b/drivers/usbhost/usbhost_storage.c
index 2b14676d714..cb6af46b86b 100644
--- a/drivers/usbhost/usbhost_storage.c
+++ b/drivers/usbhost/usbhost_storage.c
@@ -424,7 +424,7 @@ static inline void usbhost_freeclass(FAR struct usbhost_state_s *class)
 {
   DEBUGASSERT(class != NULL);
 
-  /* Free the class instance (calling sched_free() in case we are executing
+  /* Free the class instance (calling sched_kfree() in case we are executing
    * from an interrupt handler.
    */
 
diff --git a/include/nuttx/kmalloc.h b/include/nuttx/kmalloc.h
index 6a9c0da5b97..baf84ea2f53 100644
--- a/include/nuttx/kmalloc.h
+++ b/include/nuttx/kmalloc.h
@@ -1,7 +1,7 @@
 /****************************************************************************
  * include/nuttx/kmalloc.h
  *
- *   Copyright (C) 2007, 2008, 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007-2008, 2011, 2013 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -145,24 +145,31 @@ FAR void *kzalloc(size_t size);
 FAR void *krealloc(FAR void *oldmem, size_t newsize);
 void kfree(FAR void *mem);
 
+#ifdef CONFIG_DEBUG
 bool kmm_heapmember(FAR void *mem);
-
+#endif
 #endif
 
-/* Functions defined in sched/sched_free.c **********************************/
+/* Functions defined in sched/sched_kfree.c **********************************/
 
 /* Handles memory freed from an interrupt handler.  In that context, kfree()
- * cannot be called.  Instead, the allocations are saved in a list of
- * delayed allocations that will be periodically cleaned up by
+ * (or kufree()) cannot be called.  Instead, the allocations are saved in a
+ * list of delayed allocations that will be periodically cleaned up by
  * sched_garbagecollection().
  */
 
-void sched_free(FAR void *address);
+void sched_ufree(FAR void *address);
+
+#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP)
+void sched_kfree(FAR void *address);
+#else
+#  define sched_kfree(a) sched_ufree(a)
+#endif
 
 /* Functions defined in sched/sched_garbage *********************************/
 
 /* Must be called periodically to clean up deallocations delayed by
- * sched_free().  This may be done from either the IDLE thread or from a
+ * sched_kfree().  This may be done from either the IDLE thread or from a
  * worker thread.  The IDLE thread has very low priority and could starve
  * the system for memory in some context.
  */
diff --git a/libc/misc/lib_init.c b/libc/misc/lib_init.c
index 434c46505e0..efd2c806bbd 100644
--- a/libc/misc/lib_init.c
+++ b/libc/misc/lib_init.c
@@ -49,6 +49,8 @@
 
 #include "lib_internal.h"
 
+#if !defined(CONFIG_NUTTX_KERNEL) || defined(__KERNEL__)
+
 /************************************************************
  * Definitions
  ************************************************************/
@@ -138,12 +140,13 @@ void lib_releaselist(FAR struct streamlist *list)
 
       if (list->sl_streams[i].fs_bufstart)
         {
-          sched_free(list->sl_streams[i].fs_bufstart);
+          sched_ufree(list->sl_streams[i].fs_bufstart);
         }
     }
 #endif
 }
 
+#endif /* !CONFIG_NUTTX_KERNEL || __KERNEL__ */
 #endif /* CONFIG_NFILE_STREAMS */
 
 
diff --git a/mm/mm_kernel.c b/mm/mm_kernel.c
index 207d3e28f56..ff88bf0cc68 100644
--- a/mm/mm_kernel.c
+++ b/mm/mm_kernel.c
@@ -239,6 +239,7 @@ void kmm_givesemaphore(void)
  *
  ************************************************************************/
 
+#ifdef CONFIG_DEBUG
 bool kmm_heapmember(FAR void *mem)
 {
 #if CONFIG_MM_REGIONS > 1
@@ -278,5 +279,6 @@ bool kmm_heapmember(FAR void *mem)
 
 #endif
 }
+#endif
 
 #endif /* CONFIG_NUTTX_KERNEL && CONFIG_MM_KERNEL_HEAP && __KERNEL__ */
diff --git a/net/uip/uip_igmpgroup.c b/net/uip/uip_igmpgroup.c
index a530f954ca6..6e2b37f1d9a 100644
--- a/net/uip/uip_igmpgroup.c
+++ b/net/uip/uip_igmpgroup.c
@@ -378,13 +378,13 @@ void uip_grpfree(FAR struct uip_driver_s *dev, FAR struct igmp_group_s *group)
   else
 #endif
     {
-      /* No.. deallocate the group structure.  Use sched_free() just in case
+      /* No.. deallocate the group structure.  Use sched_kfree() just in case
        * this function is executing within an interrupt handler.
        */
 
       uip_unlock(flags);
-      grplldbg("Call sched_free()\n");
-      sched_free(group);
+      grplldbg("Call sched_kfree()\n");
+      sched_kfree(group);
     }
 }
 
diff --git a/sched/env_dup.c b/sched/env_dup.c
index c7a10af482e..1b061be8fa4 100644
--- a/sched/env_dup.c
+++ b/sched/env_dup.c
@@ -101,7 +101,7 @@ int env_dup(FAR struct task_group_s *group)
       /* Yes..The parent task has an environment, duplicate it */
 
       envlen = ptcb->group->tg_envsize;
-      envp   = (FAR char *)kmalloc(envlen);
+      envp   = (FAR char *)kumalloc(envlen);
       if (!envp)
         {
           ret = -ENOMEM;
diff --git a/sched/env_release.c b/sched/env_release.c
index aebb1f7e86f..c6ff7ed7540 100644
--- a/sched/env_release.c
+++ b/sched/env_release.c
@@ -85,7 +85,7 @@ void env_release(FAR struct task_group_s *group)
     {
       /* Free the environment */
 
-      sched_free(group->tg_envp);
+      sched_ufree(group->tg_envp);
     }
 
   /* In any event, make sure that all environment-related varialbles in the
diff --git a/sched/env_setenv.c b/sched/env_setenv.c
index 7ce3e1a1f1b..1b0b54c1cbe 100644
--- a/sched/env_setenv.c
+++ b/sched/env_setenv.c
@@ -161,7 +161,7 @@ int setenv(FAR const char *name, FAR const char *value, int overwrite)
   if (group->tg_envp)
     {
       newsize = group->tg_envsize + varlen;
-      newenvp = (FAR char *)krealloc(group->tg_envp, newsize);
+      newenvp = (FAR char *)kurealloc(group->tg_envp, newsize);
       if (!newenvp)
         {
           ret = ENOMEM;
@@ -173,7 +173,7 @@ int setenv(FAR const char *name, FAR const char *value, int overwrite)
   else
     {
       newsize = varlen;
-      newenvp = (FAR char *)kmalloc(varlen);
+      newenvp = (FAR char *)kumalloc(varlen);
       if (!newenvp)
         {
           ret = ENOMEM;
diff --git a/sched/env_unsetenv.c b/sched/env_unsetenv.c
index b41f58c387d..b61c7394328 100644
--- a/sched/env_unsetenv.c
+++ b/sched/env_unsetenv.c
@@ -98,7 +98,7 @@ int unsetenv(FAR const char *name)
       /* Reallocate the new environment buffer */
 
       newsize = group->tg_envsize;
-      newenvp = (FAR char *)krealloc(group->tg_envp, newsize);
+      newenvp = (FAR char *)kurealloc(group->tg_envp, newsize);
       if (!newenvp)
         {
           set_errno(ENOMEM);
diff --git a/sched/group_leave.c b/sched/group_leave.c
index 44c52a56d01..05104b34cca 100644
--- a/sched/group_leave.c
+++ b/sched/group_leave.c
@@ -213,14 +213,14 @@ static inline void group_release(FAR struct task_group_s *group)
 
   if (group->tg_members)
     {
-      sched_free(group->tg_members);
+      sched_kfree(group->tg_members);
       group->tg_members = NULL;
     }
 #endif
 
   /* Release the group container itself */
 
-  sched_free(group);
+  sched_kfree(group);
 }
 
 /*****************************************************************************
diff --git a/sched/mq_msgfree.c b/sched/mq_msgfree.c
index 91322fbf30f..61b0e1055c7 100644
--- a/sched/mq_msgfree.c
+++ b/sched/mq_msgfree.c
@@ -125,7 +125,7 @@ void mq_msgfree(FAR mqmsg_t *mqmsg)
 
   else if (mqmsg->type == MQ_ALLOC_DYN)
     {
-      sched_free(mqmsg);
+      sched_kfree(mqmsg);
     }
   else
     {
diff --git a/sched/mq_msgqfree.c b/sched/mq_msgqfree.c
index d7d87db3d80..bea598b5614 100644
--- a/sched/mq_msgqfree.c
+++ b/sched/mq_msgqfree.c
@@ -104,5 +104,5 @@ void mq_msgqfree(FAR msgq_t *msgq)
 
   /* Then deallocate the message queue itself */
 
-  sched_free(msgq);
+  sched_kfree(msgq);
 }
diff --git a/sched/mq_open.c b/sched/mq_open.c
index 64c8389b10b..7a4e39010a7 100644
--- a/sched/mq_open.c
+++ b/sched/mq_open.c
@@ -215,7 +215,7 @@ mqd_t mq_open(const char *mq_name, int oflags, ...)
                        * uninitialized, mq_deallocate() is not used.
                        */
 
-                      sched_free(msgq);
+                      sched_kfree(msgq);
                     }
                 }
             }
diff --git a/sched/os_internal.h b/sched/os_internal.h
index 71003e2da59..2aa17fa3332 100644
--- a/sched/os_internal.h
+++ b/sched/os_internal.h
@@ -216,13 +216,17 @@ extern volatile dq_queue_t g_waitingforfill;
 
 extern volatile dq_queue_t g_inactivetasks;
 
-/* This is the list of dayed memory deallocations that need to be handled
- * within the IDLE loop.  These deallocations get queued by sched_free()
- * if the OS attempts to deallocate memory while it is within an interrupt
- * handler.
+/* These are lists of dayed memory deallocations that need to be handled
+ * within the IDLE loop or worker thread.  These deallocations get queued
+ * by sched_kufree and sched_kfree() if the OS needs to deallocate memory
+ * while it is within an interrupt handler.
  */
 
-extern volatile sq_queue_t g_delayeddeallocations;
+extern volatile sq_queue_t g_delayed_kufree;
+
+#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP)
+extern volatile sq_queue_t g_delayed_kfree;
+#endif
 
 /* This is the value of the last process ID assigned to a task */
 
diff --git a/sched/os_start.c b/sched/os_start.c
index 07c5394b47f..e76f3c14b43 100644
--- a/sched/os_start.c
+++ b/sched/os_start.c
@@ -141,13 +141,17 @@ volatile dq_queue_t g_waitingforfill;
 
 volatile dq_queue_t g_inactivetasks;
 
-/* This is the list of dayed memory deallocations that need to be handled
- * within the IDLE loop.  These deallocations get queued by sched_free()
- * if the OS attempts to deallocate memory while it is within an interrupt
- * handler.
+/* These are lists of dayed memory deallocations that need to be handled
+ * within the IDLE loop or worker thread.  These deallocations get queued
+ * by sched_kufree and sched_kfree() if the OS needs to deallocate memory
+ * while it is within an interrupt handler.
  */
 
-volatile sq_queue_t g_delayeddeallocations;
+volatile sq_queue_t g_delayed_kufree;
+
+#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP)
+volatile sq_queue_t g_delayed_kfree;
+#endif
 
 /* This is the value of the last process ID assigned to a task */
 
@@ -249,7 +253,10 @@ void os_start(void)
   dq_init(&g_waitingforfill);
 #endif
   dq_init(&g_inactivetasks);
-  sq_init(&g_delayeddeallocations);
+  sq_init(&g_delayed_kufree);
+#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP)
+  sq_init(&g_delayed_kfree);
+#endif
 
   /* Initialize the logic that determine unique process IDs. */
 
diff --git a/sched/pthread_completejoin.c b/sched/pthread_completejoin.c
index 86f4eac3dc0..f3a5928e6e8 100644
--- a/sched/pthread_completejoin.c
+++ b/sched/pthread_completejoin.c
@@ -300,6 +300,6 @@ void pthread_destroyjoin(FAR struct task_group_s *group,
 
   /* And deallocate the pjoin structure */
 
-  sched_free(pjoin);
+  sched_kfree(pjoin);
 }
 
diff --git a/sched/pthread_create.c b/sched/pthread_create.c
index ce19941fcf1..346f51411ff 100644
--- a/sched/pthread_create.c
+++ b/sched/pthread_create.c
@@ -441,7 +441,7 @@ int pthread_create(FAR pthread_t *thread, FAR pthread_attr_t *attr,
   return ret;
 
 errout_with_join:
-  sched_free(pjoin);
+  sched_kfree(pjoin);
   ptcb->joininfo = NULL;
 
 errout_with_tcb:
diff --git a/sched/pthread_release.c b/sched/pthread_release.c
index 6b99b455e08..c66ff5187e1 100644
--- a/sched/pthread_release.c
+++ b/sched/pthread_release.c
@@ -114,7 +114,7 @@ void pthread_release(FAR struct task_group_s *group)
 
       /* And deallocate the join structure */
 
-      sched_free(join);
+      sched_kfree(join);
     }
 
   /* Destroy the join list semaphore */
diff --git a/sched/sched_free.c b/sched/sched_free.c
index e5e0bdacf08..7442a4d097d 100644
--- a/sched/sched_free.c
+++ b/sched/sched_free.c
@@ -1,7 +1,7 @@
 /************************************************************************
  * sched/sched_free.c
  *
- *   Copyright (C) 2007, 2009, 2012 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007, 2009, 2012-2013 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -72,18 +72,61 @@
  ************************************************************************/
 
 /************************************************************************
- * Name: sched_free
+ * Name: sched_ufree and sched_kfree
  *
  * Description:
- *   This function performs deallocations that the operating system may
- *   need to make.  This special interface to free is used to handling
+ *   These function performs deallocations that the operating system may
+ *   need to make.  This special interface to free is used in handling
  *   corner cases where the operating system may have to perform
  *   deallocations from within an interrupt handler.
  *
  ************************************************************************/
 
-void sched_free(FAR void *address)
+void sched_ufree(FAR void *address)
 {
+  irqstate_t flags;
+
+  /* Check if this is an attempt to deallocate memory from an exception
+   * handler.  If this function is called from the IDLE task, then we
+   * must have exclusive access to the memory manager to do this.
+   */
+
+  if (up_interrupt_context() || kumm_trysemaphore() != 0)
+    {
+      /* Yes.. Make sure that this is not a attempt to free kernel memory
+       * using the user deallocator.
+       */
+
+      flags = irqsave();
+#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP)
+      DEBUGASSERT(!kmm_heapmember(address));
+#endif
+
+      /* Delay the deallocation until a more appropriate time. */
+
+      sq_addlast((FAR sq_entry_t*)address, (sq_queue_t*)&g_delayed_kufree);
+
+      /* Signal the worker thread that is has some clean up to do */
+
+#ifdef CONFIG_SCHED_WORKQUEUE
+      work_signal(LPWORK);
+#endif
+      irqrestore(flags);
+    }
+  else
+    {
+      /* No.. just deallocate the memory now. */
+
+      kufree(address);
+      kumm_givesemaphore();
+    }
+}
+
+#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP)
+void sched_kfree(FAR void *address)
+{
+  irqstate_t flags;
+
   /* Check if this is an attempt to deallocate memory from an exception
    * handler.  If this function is called from the IDLE task, then we
    * must have exclusive access to the memory manager to do this.
@@ -91,17 +134,23 @@ void sched_free(FAR void *address)
 
   if (up_interrupt_context() || kmm_trysemaphore() != 0)
     {
-      /* Yes.. Delay the deallocation until a more appropriate time. */
+      /* Yes.. Make sure that this is not a attempt to free user memory
+       * using the kernel deallocator.
+       */
 
-      irqstate_t saved_state = irqsave();
-      sq_addlast((FAR sq_entry_t*)address, (sq_queue_t*)&g_delayeddeallocations);
+      flags = irqsave();
+      DEBUGASSERT(kmm_heapmember(address));
+
+      /* Delay the deallocation until a more appropriate time. */
+
+      sq_addlast((FAR sq_entry_t*)address, (sq_queue_t*)&g_delayed_kfree);
 
       /* Signal the worker thread that is has some clean up to do */
 
 #ifdef CONFIG_SCHED_WORKQUEUE
       work_signal(LPWORK);
 #endif
-      irqrestore(saved_state);
+      irqrestore(flags);
     }
   else
     {
@@ -111,4 +160,4 @@ void sched_free(FAR void *address)
       kmm_givesemaphore();
     }
 }
-
+#endif
diff --git a/sched/sched_garbage.c b/sched/sched_garbage.c
index 0eaa192476c..d11a0df96c2 100644
--- a/sched/sched_garbage.c
+++ b/sched/sched_garbage.c
@@ -62,6 +62,102 @@
  * Private Functions
  ****************************************************************************/
 
+/****************************************************************************
+ * Name: sched_kucleanup
+ *
+ * Description:
+ *   Clean-up deferred de-allocations of user memory
+ *
+ * Input parameters:
+ *   None
+ *
+ * Returned Value:
+ *   None
+ *
+ ****************************************************************************/
+
+static inline void sched_kucleanup(void)
+{
+   irqstate_t flags;
+   FAR void *address;
+
+   /* Test if the delayed deallocation queue is empty.  No special protection
+    * is needed because this is an atomic test.
+    */
+ 
+   while (g_delayed_kufree.head)
+    {
+      /* Remove the first delayed deallocation.  This is not atomic and so
+       * we must disable interrupts around the queue operation.
+       */
+
+      flags = irqsave();
+      address = (FAR void*)sq_remfirst((FAR sq_queue_t*)&g_delayed_kufree);
+      irqrestore(flags);
+
+      /* The address should always be non-NULL since that was checked in the
+       * 'while' condition above.
+       */
+
+      if (address)
+        {
+          /* Return the memory to the user heap */
+
+          kufree(address);
+        }
+    }
+}
+
+/****************************************************************************
+ * Name: sched_kcleanup
+ *
+ * Description:
+ *   Clean-up deferred de-allocations of kernel memory
+ *
+ * Input parameters:
+ *   None
+ *
+ * Returned Value:
+ *   None
+ *
+ ****************************************************************************/
+
+#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP)
+static inline void sched_kcleanup(void)
+{
+   irqstate_t flags;
+   FAR void *address;
+
+   /* Test if the delayed deallocation queue is empty.  No special protection
+    * is needed because this is an atomic test.
+    */
+ 
+   while (g_delayed_kfree.head)
+    {
+      /* Remove the first delayed deallocation.  This is not atomic and so
+       * we must disable interrupts around the queue operation.
+       */
+
+      flags = irqsave();
+      address = (FAR void*)sq_remfirst((FAR sq_queue_t*)&g_delayed_kfree);
+      irqrestore(flags);
+
+      /* The address should always be non-NULL since that was checked in the
+       * 'while' condition above.
+       */
+
+      if (address)
+        {
+          /* Return the memory to the kernel heap */
+
+          kfree(address);
+        }
+    }
+}
+#else
+#  define sched_kcleanup()
+#endif
+
 /****************************************************************************
  * Public Functions
  ****************************************************************************/
@@ -89,49 +185,11 @@
 
 void sched_garbagecollection(void)
 {
-   irqstate_t flags;
-   FAR void *address;
+  /* Handle deferred deallocations for the kernel heap */
 
-   /* Test if the delayed deallocation queue is empty.  No special protection
-    * is needed because this is an atomic test.
-    */
- 
-   while (g_delayeddeallocations.head)
-    {
-      /* Remove the first delayed deallocation.  This is not atomic and so
-       * we must disable interrupts around the queue operation.
-       */
+  sched_kcleanup();
 
-      flags = irqsave();
-      address = (FAR void*)sq_remfirst((FAR sq_queue_t*)&g_delayeddeallocations);
-      irqrestore(flags);
+  /* Handle deferred dealloctions for the user heap */
 
-      /* The address should always be non-NULL since that was checked in the
-       * 'while' condition above.
-       */
-
-      if (address)
-        {
-#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP)
-          /* Does the address to be freed lie in the kernel heap? */
-
-          if (kmm_heapmember(address))
-            {
-              /* Yes.. return the memory to the kernel heap */
-
-              kfree(address);
-            }
-
-          /* No.. then the address must lie in the user heap (unchecked) */
-
-          else
-#endif
-            {
-              /* Return the memory to the user heap */
-
-              kufree(address);
-            }
-        }
-    }
+  sched_kucleanup();
 }
-
diff --git a/sched/sched_releasetcb.c b/sched/sched_releasetcb.c
index d4d59605dde..071b0b37edf 100644
--- a/sched/sched_releasetcb.c
+++ b/sched/sched_releasetcb.c
@@ -142,7 +142,7 @@ int sched_releasetcb(FAR struct tcb_s *tcb)
         {
           if (tcb->dspace->crefs <= 1)
             {
-              sched_free(tcb->dspace);
+              sched_kfree(tcb->dspace);
             }
           else
             {
@@ -162,7 +162,7 @@ int sched_releasetcb(FAR struct tcb_s *tcb)
           FAR struct task_tcb_s *ttcb = (FAR struct task_tcb_s *)tcb;
           for (i = 1; i < CONFIG_MAX_TASK_ARGS+1 && ttcb->argv[i]; i++)
             {
-              sched_free((FAR void*)ttcb->argv[i]);
+              sched_kfree((FAR void*)ttcb->argv[i]);
             }
         }
 
@@ -179,7 +179,7 @@ int sched_releasetcb(FAR struct tcb_s *tcb)
 #endif
       /* And, finally, release the TCB itself */
 
-      sched_free(tcb);
+      sched_kfree(tcb);
     }
 
   return ret;
diff --git a/sched/sem_close.c b/sched/sem_close.c
index 169fc0448aa..22f1e0f1d9e 100644
--- a/sched/sem_close.c
+++ b/sched/sem_close.c
@@ -128,7 +128,7 @@ int sem_close(FAR sem_t *sem)
           if (!psem->nconnect && psem->unlinked)
             {
               dq_rem((FAR dq_entry_t*)psem, &g_nsems);
-              sched_free(psem);
+              sched_kfree(psem);
             }
           ret = OK;
         }
diff --git a/sched/sem_unlink.c b/sched/sem_unlink.c
index 6fe01154028..0ee262c7979 100644
--- a/sched/sem_unlink.c
+++ b/sched/sem_unlink.c
@@ -118,7 +118,7 @@ int sem_unlink(FAR const char *name)
           if (!psem->nconnect)
             {
               dq_rem((FAR dq_entry_t*)psem, &g_nsems);
-              sched_free(psem);
+              sched_kfree(psem);
             }
 
           /* If one or more process still has the semaphore open,
diff --git a/sched/sig_releasependingsigaction.c b/sched/sig_releasependingsigaction.c
index 69252f28402..b0dab2ea901 100644
--- a/sched/sig_releasependingsigaction.c
+++ b/sched/sig_releasependingsigaction.c
@@ -115,6 +115,6 @@ void sig_releasependingsigaction(FAR sigq_t *sigq)
 
   else if (sigq->type == SIG_ALLOC_DYN)
     {
-      sched_free(sigq);
+      sched_kfree(sigq);
     }
 }
diff --git a/sched/sig_releasependingsignal.c b/sched/sig_releasependingsignal.c
index 5b847bc6442..41c2286eba0 100644
--- a/sched/sig_releasependingsignal.c
+++ b/sched/sig_releasependingsignal.c
@@ -126,6 +126,6 @@ void sig_releasependingsignal(FAR sigpendq_t *sigpend)
 
   else if (sigpend->type == SIG_ALLOC_DYN)
     {
-      sched_free(sigpend);
+      sched_kfree(sigpend);
     }
 }
diff --git a/sched/timer_release.c b/sched/timer_release.c
index ed83b5f53e5..50548b3d974 100644
--- a/sched/timer_release.c
+++ b/sched/timer_release.c
@@ -97,7 +97,7 @@ static inline void timer_free(struct posix_timer_s *timer)
       /* Otherwise, return it to the heap */
 
       irqrestore(flags);
-      sched_free(timer);
+      sched_kfree(timer);
     }
 }