Add reentrance check. Put kernel debug switch together.

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@1494 bbd45198-f89e-11dd-88c7-29a3b14d5316

1 files changed, 88 insertions, 60 deletions

diff --git a/src/ipc.c b/src/ipc.c
index 762d6e6d9c..932212c4df 100644
--- a/src/ipc.c
+++ b/src/ipc.c
@@ -135,9 +135,7 @@ rt_inline rt_err_t rt_ipc_list_resume(rt_list_t *list)
 	/* get thread entry */
 	thread = rt_list_entry(list->next, struct rt_thread, tlist);
 
-#ifdef RT_IPC_DEBUG
-	rt_kprintf("resume thread:%s\n", thread->name);
-#endif
+	RT_DEBUG_LOG(RT_DEBUG_IPC,("resume thread:%s\n", thread->name));
 
 	/* resume it */
 	rt_thread_resume(thread);
@@ -253,6 +251,8 @@ rt_sem_t rt_sem_create (const char* name, rt_uint32_t value, rt_uint8_t flag)
 {
 	rt_sem_t sem;
 
+	RT_DEBUG_NOT_REENT
+
 	/* allocate object */
 	sem = (rt_sem_t) rt_object_allocate(RT_Object_Class_Semaphore, name);
 	if (sem == RT_NULL) return sem;
@@ -280,6 +280,8 @@ rt_sem_t rt_sem_create (const char* name, rt_uint32_t value, rt_uint8_t flag)
  */
 rt_err_t rt_sem_delete (rt_sem_t sem)
 {
+	RT_DEBUG_NOT_REENT
+
 	RT_ASSERT(sem != RT_NULL);
 
 	/* wakeup all suspend threads */
@@ -309,16 +311,16 @@ rt_err_t rt_sem_take (rt_sem_t sem, rt_int32_t time)
 	RT_ASSERT(sem != RT_NULL);
 
 #ifdef RT_USING_HOOK
-	if (rt_object_trytake_hook != RT_NULL) rt_object_trytake_hook(&(sem->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_trytake_hook,&(sem->parent.parent));
 #endif
 
 	/* disable interrupt */
 	temp = rt_hw_interrupt_disable();
 
-#ifdef RT_IPC_DEBU
-	rt_kprintf("thread %s take sem:%s, which value is: %d\n", rt_thread_self()->name,
-		((struct rt_object*)sem)->name, sem->value);
-#endif
+	RT_DEBUG_LOG(RT_DEBUG_IPC,
+		("thread %s take sem:%s, which value is: %d\n", rt_thread_self()->name,
+		((struct rt_object*)sem)->name, sem->value));
+
 	if (sem->value > 0)
 	{
 		/* semaphore is available */
@@ -337,6 +339,9 @@ rt_err_t rt_sem_take (rt_sem_t sem, rt_int32_t time)
 		}
 		else
 		{
+			/* time = 0 is ok */
+			RT_DEBUG_NOT_REENT
+
 			/* semaphore is unavailable, push to suspend list */
 			/* get current thread */
 			thread = rt_thread_self();
@@ -344,9 +349,8 @@ rt_err_t rt_sem_take (rt_sem_t sem, rt_int32_t time)
 			/* reset thread error number */
 			thread->error = RT_EOK;
 
-#ifdef RT_IPC_DEBUG
-			rt_kprintf("sem take: suspend thread - %s\n", thread->name);
-#endif
+			RT_DEBUG_LOG(RT_DEBUG_IPC,
+				("sem take: suspend thread - %s\n", thread->name));
 
 			/* suspend thread */
 			rt_ipc_list_suspend(&(sem->parent.suspend_thread),
@@ -355,9 +359,8 @@ rt_err_t rt_sem_take (rt_sem_t sem, rt_int32_t time)
 			/* has waiting time, start thread timer */
 			if (time > 0)
 			{
-#ifdef RT_IPC_DEBUG
-				rt_kprintf("set thread:%s to timer list\n", thread->name);
-#endif
+				RT_DEBUG_LOG(RT_DEBUG_IPC,("set thread:%s to timer list\n", thread->name));
+
 				/* reset the timeout of thread timer and start it */
 				rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &time);
 				rt_timer_start(&(thread->thread_timer));
@@ -377,7 +380,7 @@ rt_err_t rt_sem_take (rt_sem_t sem, rt_int32_t time)
 	}
 
 #ifdef RT_USING_HOOK
-	if (rt_object_take_hook != RT_NULL) rt_object_take_hook(&(sem->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_take_hook,&(sem->parent.parent));
 #endif
 
 	return RT_EOK;
@@ -409,7 +412,7 @@ rt_err_t rt_sem_release(rt_sem_t sem)
 	register rt_bool_t need_schedule;
 
 #ifdef RT_USING_HOOK
-	if (rt_object_put_hook != RT_NULL) rt_object_put_hook(&(sem->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_put_hook,&(sem->parent.parent));
 #endif
 
 	need_schedule = RT_FALSE;
@@ -417,10 +420,10 @@ rt_err_t rt_sem_release(rt_sem_t sem)
 	/* disable interrupt */
 	temp = rt_hw_interrupt_disable();
 
-#ifdef RT_IPC_DEBUG
-	rt_kprintf("thread %s releases sem:%s, which value is: %d\n", rt_thread_self()->name,
-		((struct rt_object*)sem)->name, sem->value);
-#endif
+	RT_DEBUG_LOG(RT_DEBUG_IPC,
+		("thread %s releases sem:%s, which value is: %d\n", rt_thread_self()->name,
+		((struct rt_object*)sem)->name, sem->value));
+
 
 	if ( !rt_list_isempty(&sem->parent.suspend_thread) )
 	{
@@ -549,6 +552,8 @@ rt_mutex_t rt_mutex_create (const char* name, rt_uint8_t flag)
 {
 	struct rt_mutex *mutex;
 
+	RT_DEBUG_NOT_REENT
+
 	/* allocate object */
 	mutex = (rt_mutex_t) rt_object_allocate(RT_Object_Class_Mutex, name);
 	if (mutex == RT_NULL) return mutex;
@@ -578,6 +583,8 @@ rt_mutex_t rt_mutex_create (const char* name, rt_uint8_t flag)
  */
 rt_err_t rt_mutex_delete (rt_mutex_t mutex)
 {
+	RT_DEBUG_NOT_REENT
+
 	RT_ASSERT(mutex != RT_NULL);
 
 	/* wakeup all suspend threads */
@@ -604,6 +611,9 @@ rt_err_t rt_mutex_take (rt_mutex_t mutex, rt_int32_t time)
 	register rt_base_t temp;
 	struct rt_thread* thread;
 
+	/* this function must not be used in interrupt even if time = 0 */
+	RT_DEBUG_NOT_REENT
+
 	RT_ASSERT(mutex != RT_NULL);
 
 	/* disable interrupt */
@@ -613,13 +623,12 @@ rt_err_t rt_mutex_take (rt_mutex_t mutex, rt_int32_t time)
 	thread = rt_thread_self();
 
 #ifdef RT_USING_HOOK
-	if (rt_object_trytake_hook != RT_NULL) rt_object_trytake_hook(&(mutex->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_trytake_hook,&(mutex->parent.parent));
 #endif
 
-#ifdef RT_IPC_DEBUG
-	rt_kprintf("mutex_take: current thread %s, mutex value: %d, hold: %d\n",
-		thread->name, mutex->value, mutex->hold);
-#endif
+	RT_DEBUG_LOG(RT_DEBUG_IPC,
+		("mutex_take: current thread %s, mutex value: %d, hold: %d\n",
+		thread->name, mutex->value, mutex->hold));
 
 	/* reset thread error */
 	thread->error = RT_EOK;
@@ -660,9 +669,9 @@ rt_err_t rt_mutex_take (rt_mutex_t mutex, rt_int32_t time)
 			else
 			{
 				/* mutex is unavailable, push to suspend list */
-#ifdef RT_IPC_DEBUG
-				rt_kprintf("mutex_take: suspend thread: %s\n", thread->name);
-#endif
+				RT_DEBUG_LOG(RT_DEBUG_IPC,
+					("mutex_take: suspend thread: %s\n", thread->name));
+
 				/* change the owner thread priority of mutex */
 				if (thread->current_priority < mutex->owner->current_priority)
 				{
@@ -678,9 +687,9 @@ rt_err_t rt_mutex_take (rt_mutex_t mutex, rt_int32_t time)
 				/* has waiting time, start thread timer */
 				if (time > 0)
 				{
-#ifdef RT_IPC_DEBUG
-					rt_kprintf("mutex_take: start the timer of thread:%s\n", thread->name);
-#endif
+					RT_DEBUG_LOG(RT_DEBUG_IPC,
+						("mutex_take: start the timer of thread:%s\n", thread->name));
+
 					/* reset the timeout of thread timer and start it */
 					rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &time);
 					rt_timer_start(&(thread->thread_timer));
@@ -711,7 +720,7 @@ rt_err_t rt_mutex_take (rt_mutex_t mutex, rt_int32_t time)
 	rt_hw_interrupt_enable(temp);
 
 #ifdef RT_USING_HOOK
-	if (rt_object_take_hook != RT_NULL) rt_object_take_hook(&(mutex->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_take_hook,&(mutex->parent.parent));
 #endif
 
 	return RT_EOK;
@@ -739,13 +748,12 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex)
 	/* disable interrupt */
 	temp = rt_hw_interrupt_disable();
 
-#ifdef RT_IPC_DEBUG
-	rt_kprintf("mutex_release:current thread %s, mutex value: %d, hold: %d\n",
-		thread->name, mutex->value, mutex->hold);
-#endif
+	RT_DEBUG_LOG(RT_DEBUG_IPC,
+		("mutex_release:current thread %s, mutex value: %d, hold: %d\n",
+		thread->name, mutex->value, mutex->hold));
 
 #ifdef RT_USING_HOOK
-	if (rt_object_put_hook != RT_NULL) rt_object_put_hook(&(mutex->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_put_hook,&(mutex->parent.parent));
 #endif
 
 	/* mutex only can be released by owner */
@@ -777,9 +785,9 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex)
 			/* get suspended thread */
 			thread = rt_list_entry(mutex->parent.suspend_thread.next, struct rt_thread, tlist);
 
-#ifdef RT_IPC_DEBUG
-			rt_kprintf("mutex_release: resume thread: %s\n", thread->name);
-#endif
+			RT_DEBUG_LOG(RT_DEBUG_IPC,
+				("mutex_release: resume thread: %s\n", thread->name));
+
 			/* set new owner and priority */
 			mutex->owner = thread;
 			mutex->original_priority = thread->current_priority;
@@ -891,6 +899,8 @@ rt_event_t rt_event_create (const char* name, rt_uint8_t flag)
 {
 	rt_event_t event;
 
+	RT_DEBUG_NOT_REENT
+
 	/* allocate object */
 	event = (rt_event_t) rt_object_allocate(RT_Object_Class_Event, name);
 	if (event == RT_NULL) return event;
@@ -919,6 +929,8 @@ rt_err_t rt_event_delete (rt_event_t event)
 	/* parameter check */
 	RT_ASSERT(event != RT_NULL);
 
+	RT_DEBUG_NOT_REENT
+
 	/* resume all suspended thread */
 	rt_ipc_list_resume_all(&(event->parent.suspend_thread));
 
@@ -952,7 +964,7 @@ rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set)
 
 	need_schedule = RT_FALSE;
 #ifdef RT_USING_HOOK
-	if (rt_object_put_hook != RT_NULL) rt_object_put_hook(&(event->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_put_hook,&(event->parent.parent));
 #endif
 
 	/* disable interrupt */
@@ -1039,6 +1051,8 @@ rt_err_t rt_event_recv(rt_event_t event, rt_uint32_t set, rt_uint8_t option, rt_
 	register rt_ubase_t level;
 	register rt_base_t status;
 
+	RT_DEBUG_NOT_REENT
+
 	/* parameter check */
 	RT_ASSERT(event != RT_NULL);
 	if (set == 0) return -RT_ERROR;
@@ -1051,7 +1065,7 @@ rt_err_t rt_event_recv(rt_event_t event, rt_uint32_t set, rt_uint8_t option, rt_
 	thread->error = RT_EOK;
 
 #ifdef RT_USING_HOOK
-	if (rt_object_trytake_hook != RT_NULL) rt_object_trytake_hook(&(event->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_trytake_hook,&(event->parent.parent));
 #endif
 
 	/* disable interrupt */
@@ -1121,7 +1135,7 @@ rt_err_t rt_event_recv(rt_event_t event, rt_uint32_t set, rt_uint8_t option, rt_
 	rt_hw_interrupt_enable(level);
 
 #ifdef RT_USING_HOOK
-	if (rt_object_take_hook != RT_NULL) rt_object_take_hook(&(event->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_take_hook,&(event->parent.parent));
 #endif
 
 	return thread->error;
@@ -1240,6 +1254,8 @@ rt_mailbox_t rt_mb_create (const char* name, rt_size_t size, rt_uint8_t flag)
 {
 	rt_mailbox_t mb;
 
+	RT_DEBUG_NOT_REENT
+
 	/* allocate object */
 	mb = (rt_mailbox_t) rt_object_allocate(RT_Object_Class_MailBox, name);
 	if (mb == RT_NULL) return mb;
@@ -1279,6 +1295,8 @@ rt_mailbox_t rt_mb_create (const char* name, rt_size_t size, rt_uint8_t flag)
  */
 rt_err_t rt_mb_delete (rt_mailbox_t mb)
 {
+	RT_DEBUG_NOT_REENT
+
 	/* parameter check */
 	RT_ASSERT(mb != RT_NULL);
 
@@ -1325,7 +1343,7 @@ rt_err_t rt_mb_send_wait (rt_mailbox_t mb, rt_uint32_t value, rt_int32_t timeout
 	RT_ASSERT(mb != RT_NULL);
 
 #ifdef RT_USING_HOOK
-	if (rt_object_put_hook != RT_NULL) rt_object_put_hook(&(mb->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_put_hook,&(mb->parent.parent));
 #endif
 
 	/* disable interrupt */
@@ -1350,6 +1368,8 @@ rt_err_t rt_mb_send_wait (rt_mailbox_t mb, rt_uint32_t value, rt_int32_t timeout
             return -RT_EFULL;
         }
 
+		RT_DEBUG_NOT_REENT
+	
 		/* suspend current thread */
 		rt_ipc_list_suspend(&(mb->suspend_sender_thread),
 				thread, mb->parent.parent.flag);
@@ -1360,9 +1380,9 @@ rt_err_t rt_mb_send_wait (rt_mailbox_t mb, rt_uint32_t value, rt_int32_t timeout
 			/* get the start tick of timer */
 			tick_delta = rt_tick_get();
 
-#ifdef RT_IPC_DEBUG
-			rt_kprintf("mb_send_wait: start timer of thread:%s\n", thread->name);
-#endif
+			RT_DEBUG_LOG(RT_DEBUG_IPC,
+				("mb_send_wait: start timer of thread:%s\n", thread->name));
+
 			/* reset the timeout of thread timer and start it */
 			rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &timeout);
 			rt_timer_start(&(thread->thread_timer));
@@ -1456,7 +1476,7 @@ rt_err_t rt_mb_recv (rt_mailbox_t mb, rt_uint32_t* value, rt_int32_t timeout)
 
 	tick_delta = 0;
 #ifdef RT_USING_HOOK
-	if (rt_object_trytake_hook != RT_NULL) rt_object_trytake_hook(&(mb->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_trytake_hook,&(mb->parent.parent));
 #endif
 
 	/* disable interrupt */
@@ -1481,6 +1501,8 @@ rt_err_t rt_mb_recv (rt_mailbox_t mb, rt_uint32_t* value, rt_int32_t timeout)
 			return -RT_ETIMEOUT;
 		}
 
+		RT_DEBUG_NOT_REENT
+
 		/* suspend current thread */
 		rt_ipc_list_suspend(&(mb->parent.suspend_thread),
 				thread, mb->parent.parent.flag);
@@ -1491,9 +1513,9 @@ rt_err_t rt_mb_recv (rt_mailbox_t mb, rt_uint32_t* value, rt_int32_t timeout)
 			/* get the start tick of timer */
 			tick_delta = rt_tick_get();
 
-#ifdef RT_IPC_DEBUG
-			rt_kprintf("mb_recv: start timer of thread:%s\n", thread->name);
-#endif
+			RT_DEBUG_LOG(RT_DEBUG_IPC,
+				("mb_recv: start timer of thread:%s\n", thread->name));
+
 			/* reset the timeout of thread timer and start it */
 			rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &timeout);
 			rt_timer_start(&(thread->thread_timer));
@@ -1542,7 +1564,7 @@ rt_err_t rt_mb_recv (rt_mailbox_t mb, rt_uint32_t* value, rt_int32_t timeout)
 		rt_hw_interrupt_enable(temp);
 
 #ifdef RT_USING_HOOK
-	if (rt_object_take_hook != RT_NULL) rt_object_take_hook(&(mb->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_take_hook,&(mb->parent.parent));
 #endif
 		rt_schedule();
 
@@ -1553,7 +1575,7 @@ rt_err_t rt_mb_recv (rt_mailbox_t mb, rt_uint32_t* value, rt_int32_t timeout)
 	rt_hw_interrupt_enable(temp);
 
 #ifdef RT_USING_HOOK
-	if (rt_object_take_hook != RT_NULL) rt_object_take_hook(&(mb->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_take_hook,&(mb->parent.parent));
 #endif
 
 	return RT_EOK;
@@ -1702,6 +1724,8 @@ rt_mq_t rt_mq_create (const char* name, rt_size_t msg_size, rt_size_t max_msgs,
 	struct rt_mq_message* head;
 	register rt_base_t temp;
 
+	RT_DEBUG_NOT_REENT
+
 	/* allocate object */
 	mq = (rt_mq_t) rt_object_allocate(RT_Object_Class_MessageQueue, name);
 	if (mq == RT_NULL) return mq;
@@ -1755,6 +1779,8 @@ rt_mq_t rt_mq_create (const char* name, rt_size_t msg_size, rt_size_t max_msgs,
  */
 rt_err_t rt_mq_delete (rt_mq_t mq)
 {
+	RT_DEBUG_NOT_REENT
+
 	/* parameter check */
 	RT_ASSERT(mq != RT_NULL);
 
@@ -1797,7 +1823,7 @@ rt_err_t rt_mq_send (rt_mq_t mq, void* buffer, rt_size_t size)
 	if (size > mq->msg_size) return -RT_ERROR;
 
 #ifdef RT_USING_HOOK
-	if (rt_object_put_hook != RT_NULL) rt_object_put_hook(&(mq->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_put_hook,&(mq->parent.parent));
 #endif
 
 	/* disable interrupt */
@@ -1880,7 +1906,7 @@ rt_err_t rt_mq_urgent(rt_mq_t mq, void* buffer, rt_size_t size)
 	if (size > mq->msg_size) return -RT_ERROR;
 
 #ifdef RT_USING_HOOK
-	if (rt_object_put_hook != RT_NULL) rt_object_put_hook(&(mq->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_put_hook,&(mq->parent.parent));
 #endif
 
 	/* disable interrupt */
@@ -1955,7 +1981,7 @@ rt_err_t rt_mq_recv (rt_mq_t mq, void* buffer, rt_size_t size, rt_int32_t timeou
 	rt_uint32_t tick_delta;
 
 #ifdef RT_USING_HOOK
-	if (rt_object_trytake_hook != RT_NULL) rt_object_trytake_hook(&(mq->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_trytake_hook,&(mq->parent.parent));
 #endif
 
 	tick_delta = 0;
@@ -1981,6 +2007,8 @@ rt_err_t rt_mq_recv (rt_mq_t mq, void* buffer, rt_size_t size, rt_int32_t timeou
 			return -RT_ETIMEOUT;
 		}
 
+		RT_DEBUG_NOT_REENT
+
 		/* suspend current thread */
 		rt_ipc_list_suspend(&(mq->parent.suspend_thread),
 				thread, mq->parent.parent.flag);
@@ -1991,9 +2019,9 @@ rt_err_t rt_mq_recv (rt_mq_t mq, void* buffer, rt_size_t size, rt_int32_t timeou
 			/* get the start tick of timer */
 			tick_delta = rt_tick_get();
 
-#ifdef RT_IPC_DEBUG
-			rt_kprintf("set thread:%s to timer list\n", thread->name);
-#endif
+			RT_DEBUG_LOG(RT_DEBUG_IPC,
+				("set thread:%s to timer list\n", thread->name));
+
 			/* reset the timeout of thread timer and start it */
 			rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &timeout);
 			rt_timer_start(&(thread->thread_timer));
@@ -2051,7 +2079,7 @@ rt_err_t rt_mq_recv (rt_mq_t mq, void* buffer, rt_size_t size, rt_int32_t timeou
 	rt_hw_interrupt_enable(temp);
 
 #ifdef RT_USING_HOOK
-	if (rt_object_take_hook != RT_NULL) rt_object_take_hook(&(mq->parent.parent));
+	RT_OBJECT_HOOK_CALL2(rt_object_take_hook,&(mq->parent.parent));
 #endif
 
 	return RT_EOK;