diff --git a/include/rtdef.h b/include/rtdef.h
index b25a6a87d57c1a5ae2e2b9f3fd92ec1f17ecdd07..3dc8a2a2a9401ba9e2703510ca256f936cb48d4c 100644
--- a/include/rtdef.h
+++ b/include/rtdef.h
@@ -577,6 +577,7 @@ struct rt_thread
 
     rt_uint16_t scheduler_lock_nest;                    /**< scheduler lock count */
     rt_uint16_t cpus_lock_nest;                         /**< cpus lock count */
+    rt_uint16_t critical_lock_nest;                     /**< critical lock count */
 #endif /*RT_USING_SMP*/
 
     /* priority */
diff --git a/include/rthw.h b/include/rthw.h
index ef3dc087ad0c1d3e4b2b40e9cbedadbc5ea407be..a77f2c1e466f8e121a8ddb8c26bcb0c822ef513f 100644
--- a/include/rthw.h
+++ b/include/rthw.h
@@ -143,6 +143,12 @@ typedef union {
     } tickets;
 } rt_hw_spinlock_t;
 
+typedef struct
+{
+    rt_hw_spinlock_t lock;
+} rt_spinlock_t;
+
+void rt_hw_spin_lock_init(rt_hw_spinlock_t *lock);
 void rt_hw_spin_lock(rt_hw_spinlock_t *lock);
 void rt_hw_spin_unlock(rt_hw_spinlock_t *lock);
 
@@ -181,8 +187,16 @@ void rt_hw_secondary_cpu_idle_exec(void);
 #define rt_hw_spin_lock(lock)     *(lock) = rt_hw_interrupt_disable()
 #define rt_hw_spin_unlock(lock)   rt_hw_interrupt_enable(*(lock))
 
+typedef int rt_spinlock_t;
+
 #endif
 
+void rt_spin_lock_init(rt_spinlock_t *lock);
+void rt_spin_lock(rt_spinlock_t *lock);
+void rt_spin_unlock(rt_spinlock_t *lock);
+rt_base_t rt_spin_lock_irqsave(rt_spinlock_t *lock);
+void rt_spin_unlock_irqrestore(rt_spinlock_t *lock, rt_base_t level);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/libcpu/arm/cortex-a/cpu.c b/libcpu/arm/cortex-a/cpu.c
index 6b129f89eee4334361781d13c5a3c5409460c5fe..7c6bf58a4bea14dbaa6c440b7ba7ae5a099c108d 100644
--- a/libcpu/arm/cortex-a/cpu.c
+++ b/libcpu/arm/cortex-a/cpu.c
@@ -14,6 +14,7 @@
 #include <board.h>
 
 #ifdef RT_USING_SMP
+
 int rt_hw_cpu_id(void)
 {
     int cpu_id;
@@ -25,6 +26,11 @@ int rt_hw_cpu_id(void)
     return cpu_id;
 };
 
+void rt_hw_spin_lock_init(rt_hw_spinlock_t *lock)
+{
+    lock->slock = 0;
+}
+
 void rt_hw_spin_lock(rt_hw_spinlock_t *lock)
 {
     unsigned long tmp;
diff --git a/libcpu/risc-v/k210/cpuport_smp.c b/libcpu/risc-v/k210/cpuport_smp.c
index a31314a13fd1b46f0a26a87833638084a81ad388..8c57dfeafce8606d39eca4859cfc7da046add92d 100644
--- a/libcpu/risc-v/k210/cpuport_smp.c
+++ b/libcpu/risc-v/k210/cpuport_smp.c
@@ -25,6 +25,11 @@ int rt_hw_cpu_id(void)
     return read_csr(mhartid);
 }
 
+void rt_hw_spin_lock_init(rt_hw_spinlock_t *lock)
+{
+    ((spinlock_t *)lock)->lock = 0;
+}
+
 void rt_hw_spin_lock(rt_hw_spinlock_t *lock)
 {
     spinlock_lock((spinlock_t *)lock);
diff --git a/src/cpu.c b/src/cpu.c
index fe3ba21bb00ced3ef5891e49e1108b563fbccc03..a4075108e189f9d4f5ccbe20a9837a60f24a2738 100644
--- a/src/cpu.c
+++ b/src/cpu.c
@@ -11,6 +11,119 @@
 #include <rtthread.h>
 #include <rthw.h>
 
+#ifdef RT_USING_SMP
+/***********************************
+ * disable scheduler
+ ***********************************/
+static void rt_preempt_disable(void)
+{
+	register rt_base_t level;
+	struct rt_thread *current_thread;
+
+	/* disable interrupt */
+	level = rt_hw_local_irq_disable();
+
+	current_thread = rt_cpu_self()->current_thread;
+	if (!current_thread)
+	{
+		rt_hw_local_irq_enable(level);
+		return;
+	}
+
+	/* lock scheduler for local cpu */
+	current_thread->scheduler_lock_nest ++;
+
+	/* enable interrupt */
+	rt_hw_local_irq_enable(level);
+}
+
+/***********************************
+ * restore scheduler
+ ***********************************/
+static void rt_preempt_enable(void)
+{
+	register rt_base_t level;
+	struct rt_thread *current_thread;
+
+	/* disable interrupt */
+	level = rt_hw_local_irq_disable();
+
+	current_thread = rt_cpu_self()->current_thread;
+	if (!current_thread)
+	{
+		rt_hw_local_irq_enable(level);
+		return;
+	}
+
+	/* unlock scheduler for local cpu */
+	current_thread->scheduler_lock_nest --;
+
+	rt_schedule();
+	/* enable interrupt */
+	rt_hw_local_irq_enable(level);
+}
+#endif
+
+void rt_spin_lock_init(rt_spinlock_t *lock)
+{
+#ifdef RT_USING_SMP
+	rt_hw_spin_lock_init(&lock->lock);
+#endif
+}
+RTM_EXPORT(rt_spin_lock_init)
+
+void rt_spin_lock(rt_spinlock_t *lock)
+{
+#ifdef RT_USING_SMP
+	rt_preempt_disable();
+	rt_hw_spin_lock(&lock->lock);
+#else
+    rt_enter_critical();
+#endif
+}
+RTM_EXPORT(rt_spin_lock)
+
+void rt_spin_unlock(rt_spinlock_t *lock)
+{
+#ifdef RT_USING_SMP
+	rt_hw_spin_unlock(&lock->lock);
+	rt_preempt_enable();
+#else
+    rt_exit_critical();
+#endif
+}
+RTM_EXPORT(rt_spin_unlock)
+
+rt_base_t rt_spin_lock_irqsave(rt_spinlock_t *lock)
+{
+	unsigned long level;
+
+#ifdef RT_USING_SMP
+	rt_preempt_disable();
+
+	level = rt_hw_local_irq_disable();
+	rt_hw_spin_lock(&lock->lock);
+
+	return level;
+#else
+    return rt_hw_interrupt_disable();
+#endif
+}
+RTM_EXPORT(rt_spin_lock_irqsave)
+
+void rt_spin_unlock_irqrestore(rt_spinlock_t *lock, rt_base_t level)
+{
+#ifdef RT_USING_SMP
+	rt_hw_spin_unlock(&lock->lock);
+	rt_hw_local_irq_enable(level);
+
+	rt_preempt_enable();
+#else
+    rt_hw_interrupt_enable(level);
+#endif
+}
+RTM_EXPORT(rt_spin_unlock_irqrestore)
+
 #ifdef RT_USING_SMP
 
 static struct rt_cpu rt_cpus[RT_CPUS_NR];
diff --git a/src/scheduler.c b/src/scheduler.c
index b487bd4b609505fe8dd01f270039e2adeab19848..0faafaa2fc3b8f9510be2fd407d8846419e67fb0 100644
--- a/src/scheduler.c
+++ b/src/scheduler.c
@@ -840,11 +840,14 @@ void rt_enter_critical(void)
      */
 
     /* lock scheduler for all cpus */
-    if (current_thread->scheduler_lock_nest == !!current_thread->cpus_lock_nest)
+    if (current_thread->critical_lock_nest == 0)
     {
         rt_hw_spin_lock(&_rt_critical_lock);
     }
 
+    /* critical for local cpu */
+    current_thread->critical_lock_nest ++;
+
     /* lock scheduler for local cpu */
     current_thread->scheduler_lock_nest ++;
 
@@ -892,7 +895,9 @@ void rt_exit_critical(void)
 
     current_thread->scheduler_lock_nest --;
 
-    if (current_thread->scheduler_lock_nest == !!current_thread->cpus_lock_nest)
+    current_thread->critical_lock_nest --;
+
+    if (current_thread->critical_lock_nest == 0)
     {
         rt_hw_spin_unlock(&_rt_critical_lock);
     }
@@ -951,7 +956,7 @@ rt_uint16_t rt_critical_level(void)
 #ifdef RT_USING_SMP
     struct rt_thread *current_thread = rt_cpu_self()->current_thread;
 
-    return current_thread->scheduler_lock_nest;
+    return current_thread->critical_lock_nest;
 #else
 	return rt_scheduler_lock_nest;
 #endif /*RT_USING_SMP*/
diff --git a/src/thread.c b/src/thread.c
index ab203b1d49a7642e8191f322cb731229fd946a7d..a88729e52c34e0c8e805f6dd9f9e0b6cb727c886 100644
--- a/src/thread.c
+++ b/src/thread.c
@@ -172,6 +172,7 @@ static rt_err_t _rt_thread_init(struct rt_thread *thread,
     /* lock init */
     thread->scheduler_lock_nest = 0;
     thread->cpus_lock_nest = 0;
+    thread->critical_lock_nest = 0;
 #endif /*RT_USING_SMP*/
 
     /* initialize cleanup function and user data */