2009-07-03 06:48:23 +08:00
|
|
|
/*
|
2018-09-14 22:37:43 +08:00
|
|
|
* Copyright (c) 2006-2018, RT-Thread Development Team
|
2013-06-24 17:06:09 +08:00
|
|
|
*
|
2018-09-14 22:37:43 +08:00
|
|
|
* SPDX-License-Identifier: Apache-2.0
|
2009-07-03 06:48:23 +08:00
|
|
|
*
|
|
|
|
* Change Logs:
|
|
|
|
* Date Author Notes
|
|
|
|
* 2006-03-28 Bernard first version
|
|
|
|
* 2006-04-29 Bernard implement thread timer
|
2011-09-08 10:17:18 +08:00
|
|
|
* 2006-04-30 Bernard added THREAD_DEBUG
|
|
|
|
* 2006-05-27 Bernard fixed the rt_thread_yield bug
|
|
|
|
* 2006-06-03 Bernard fixed the thread timer init bug
|
|
|
|
* 2006-08-10 Bernard fixed the timer bug in thread_sleep
|
|
|
|
* 2006-09-03 Bernard changed rt_timer_delete to rt_timer_detach
|
2009-07-03 06:48:23 +08:00
|
|
|
* 2006-09-03 Bernard implement rt_thread_detach
|
2011-09-08 10:17:18 +08:00
|
|
|
* 2008-02-16 Bernard fixed the rt_thread_timeout bug
|
2012-12-21 16:48:30 +08:00
|
|
|
* 2010-03-21 Bernard change the errno of rt_thread_delay/sleep to
|
|
|
|
* RT_EOK.
|
2010-11-12 18:16:33 +08:00
|
|
|
* 2010-11-10 Bernard add cleanup callback function in thread exit.
|
2012-12-21 16:48:30 +08:00
|
|
|
* 2011-09-01 Bernard fixed rt_thread_exit issue when the current
|
|
|
|
* thread preempted, which reported by Jiaxing Lee.
|
2011-09-08 10:17:18 +08:00
|
|
|
* 2011-09-08 Bernard fixed the scheduling issue in rt_thread_startup.
|
2012-12-29 20:29:03 +08:00
|
|
|
* 2012-12-29 Bernard fixed compiling warning.
|
2016-08-09 11:29:11 +08:00
|
|
|
* 2016-08-09 ArdaFu add thread suspend and resume hook.
|
2017-04-10 09:53:45 +08:00
|
|
|
* 2017-04-10 armink fixed the rt_thread_delete and rt_thread_detach
|
2018-11-22 14:40:43 +08:00
|
|
|
* bug when thread has not startup.
|
|
|
|
* 2018-11-22 Jesven yield is same to rt_schedule
|
|
|
|
* add support for tasks bound to cpu
|
2009-07-03 06:48:23 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <rthw.h>
|
2018-11-22 14:40:43 +08:00
|
|
|
#include <rtthread.h>
|
2009-07-03 06:48:23 +08:00
|
|
|
|
|
|
|
extern rt_list_t rt_thread_defunct;
|
|
|
|
|
2016-08-09 11:29:11 +08:00
|
|
|
#ifdef RT_USING_HOOK
|
|
|
|
static void (*rt_thread_suspend_hook)(rt_thread_t thread);
|
2017-04-09 19:12:53 +08:00
|
|
|
static void (*rt_thread_resume_hook) (rt_thread_t thread);
|
|
|
|
static void (*rt_thread_inited_hook) (rt_thread_t thread);
|
|
|
|
|
2016-08-09 11:29:11 +08:00
|
|
|
/**
|
|
|
|
* @ingroup Hook
|
2017-09-15 11:02:24 +08:00
|
|
|
* This function sets a hook function when the system suspend a thread.
|
2016-08-09 11:29:11 +08:00
|
|
|
*
|
|
|
|
* @param hook the specified hook function
|
|
|
|
*
|
|
|
|
* @note the hook function must be simple and never be blocked or suspend.
|
|
|
|
*/
|
|
|
|
void rt_thread_suspend_sethook(void (*hook)(rt_thread_t thread))
|
|
|
|
{
|
|
|
|
rt_thread_suspend_hook = hook;
|
|
|
|
}
|
2017-04-09 19:12:53 +08:00
|
|
|
|
2016-08-09 11:29:11 +08:00
|
|
|
/**
|
|
|
|
* @ingroup Hook
|
2017-09-15 11:02:24 +08:00
|
|
|
* This function sets a hook function when the system resume a thread.
|
2016-08-09 11:29:11 +08:00
|
|
|
*
|
|
|
|
* @param hook the specified hook function
|
|
|
|
*
|
|
|
|
* @note the hook function must be simple and never be blocked or suspend.
|
|
|
|
*/
|
|
|
|
void rt_thread_resume_sethook(void (*hook)(rt_thread_t thread))
|
|
|
|
{
|
|
|
|
rt_thread_resume_hook = hook;
|
|
|
|
}
|
2017-04-09 19:12:53 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup Hook
|
2017-09-15 11:02:24 +08:00
|
|
|
* This function sets a hook function when a thread is initialized.
|
2017-04-09 19:12:53 +08:00
|
|
|
*
|
|
|
|
* @param hook the specified hook function
|
|
|
|
*/
|
|
|
|
void rt_thread_inited_sethook(void (*hook)(rt_thread_t thread))
|
|
|
|
{
|
2017-09-15 11:02:24 +08:00
|
|
|
rt_thread_inited_hook = hook;
|
2017-04-09 19:12:53 +08:00
|
|
|
}
|
|
|
|
|
2016-08-09 11:29:11 +08:00
|
|
|
#endif
|
|
|
|
|
2016-04-05 14:40:49 +08:00
|
|
|
void rt_thread_exit(void)
|
2012-01-09 19:52:03 +08:00
|
|
|
{
|
2012-12-21 16:48:30 +08:00
|
|
|
struct rt_thread *thread;
|
|
|
|
register rt_base_t level;
|
|
|
|
|
|
|
|
/* get current thread */
|
2018-11-22 14:40:43 +08:00
|
|
|
thread = rt_thread_self();
|
2012-12-21 16:48:30 +08:00
|
|
|
|
|
|
|
/* disable interrupt */
|
|
|
|
level = rt_hw_interrupt_disable();
|
|
|
|
|
|
|
|
/* remove from schedule */
|
|
|
|
rt_schedule_remove_thread(thread);
|
|
|
|
/* change stat */
|
|
|
|
thread->stat = RT_THREAD_CLOSE;
|
|
|
|
|
|
|
|
/* remove it from timer list */
|
2013-09-26 15:52:02 +08:00
|
|
|
rt_timer_detach(&thread->thread_timer);
|
2012-12-21 16:48:30 +08:00
|
|
|
|
|
|
|
if ((rt_object_is_systemobject((rt_object_t)thread) == RT_TRUE) &&
|
|
|
|
thread->cleanup == RT_NULL)
|
|
|
|
{
|
|
|
|
rt_object_detach((rt_object_t)thread);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* insert to defunct thread list */
|
|
|
|
rt_list_insert_after(&rt_thread_defunct, &(thread->tlist));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* enable interrupt */
|
|
|
|
rt_hw_interrupt_enable(level);
|
|
|
|
|
|
|
|
/* switch to next task */
|
|
|
|
rt_schedule();
|
2012-01-09 19:52:03 +08:00
|
|
|
}
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
static rt_err_t _rt_thread_init(struct rt_thread *thread,
|
2012-12-21 16:48:30 +08:00
|
|
|
const char *name,
|
|
|
|
void (*entry)(void *parameter),
|
|
|
|
void *parameter,
|
|
|
|
void *stack_start,
|
|
|
|
rt_uint32_t stack_size,
|
|
|
|
rt_uint8_t priority,
|
|
|
|
rt_uint32_t tick)
|
2009-07-03 06:48:23 +08:00
|
|
|
{
|
2012-12-21 16:48:30 +08:00
|
|
|
/* init thread list */
|
|
|
|
rt_list_init(&(thread->tlist));
|
|
|
|
|
|
|
|
thread->entry = (void *)entry;
|
|
|
|
thread->parameter = parameter;
|
|
|
|
|
|
|
|
/* stack init */
|
|
|
|
thread->stack_addr = stack_start;
|
2016-05-31 20:39:33 +08:00
|
|
|
thread->stack_size = stack_size;
|
2012-12-21 16:48:30 +08:00
|
|
|
|
|
|
|
/* init thread stack */
|
|
|
|
rt_memset(thread->stack_addr, '#', thread->stack_size);
|
2018-11-11 15:56:02 +08:00
|
|
|
#ifdef ARCH_CPU_STACK_GROWS_UPWARD
|
|
|
|
thread->sp = (void *)rt_hw_stack_init(thread->entry, thread->parameter,
|
|
|
|
(void *)((char *)thread->stack_addr),
|
|
|
|
(void *)rt_thread_exit);
|
|
|
|
#else
|
2012-12-21 16:48:30 +08:00
|
|
|
thread->sp = (void *)rt_hw_stack_init(thread->entry, thread->parameter,
|
2019-06-18 20:09:19 +08:00
|
|
|
(rt_uint8_t *)((char *)thread->stack_addr + thread->stack_size - sizeof(rt_ubase_t)),
|
2017-09-15 11:02:24 +08:00
|
|
|
(void *)rt_thread_exit);
|
2018-11-11 15:56:02 +08:00
|
|
|
#endif
|
2012-12-21 16:48:30 +08:00
|
|
|
|
|
|
|
/* priority init */
|
|
|
|
RT_ASSERT(priority < RT_THREAD_PRIORITY_MAX);
|
|
|
|
thread->init_priority = priority;
|
|
|
|
thread->current_priority = priority;
|
|
|
|
|
2017-06-15 23:30:18 +08:00
|
|
|
thread->number_mask = 0;
|
|
|
|
#if RT_THREAD_PRIORITY_MAX > 32
|
|
|
|
thread->number = 0;
|
2017-06-26 09:16:19 +08:00
|
|
|
thread->high_mask = 0;
|
2017-06-15 23:30:18 +08:00
|
|
|
#endif
|
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* tick init */
|
|
|
|
thread->init_tick = tick;
|
|
|
|
thread->remaining_tick = tick;
|
|
|
|
|
|
|
|
/* error and flags */
|
|
|
|
thread->error = RT_EOK;
|
|
|
|
thread->stat = RT_THREAD_INIT;
|
|
|
|
|
2018-11-22 14:40:43 +08:00
|
|
|
#ifdef RT_USING_SMP
|
|
|
|
/* not bind on any cpu */
|
|
|
|
thread->bind_cpu = RT_CPUS_NR;
|
|
|
|
thread->oncpu = RT_CPU_DETACHED;
|
|
|
|
|
|
|
|
/* lock init */
|
|
|
|
thread->scheduler_lock_nest = 0;
|
|
|
|
thread->cpus_lock_nest = 0;
|
2019-09-26 18:13:07 +08:00
|
|
|
thread->critical_lock_nest = 0;
|
2018-11-22 14:40:43 +08:00
|
|
|
#endif /*RT_USING_SMP*/
|
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* initialize cleanup function and user data */
|
|
|
|
thread->cleanup = 0;
|
|
|
|
thread->user_data = 0;
|
|
|
|
|
|
|
|
/* init thread timer */
|
|
|
|
rt_timer_init(&(thread->thread_timer),
|
|
|
|
thread->name,
|
|
|
|
rt_thread_timeout,
|
|
|
|
thread,
|
|
|
|
0,
|
|
|
|
RT_TIMER_FLAG_ONE_SHOT);
|
|
|
|
|
2017-10-15 22:31:53 +08:00
|
|
|
/* initialize signal */
|
|
|
|
#ifdef RT_USING_SIGNALS
|
|
|
|
thread->sig_mask = 0x00;
|
|
|
|
thread->sig_pending = 0x00;
|
|
|
|
|
2019-05-09 19:28:52 +08:00
|
|
|
#ifndef RT_USING_SMP
|
2017-10-15 22:31:53 +08:00
|
|
|
thread->sig_ret = RT_NULL;
|
2019-05-09 19:28:52 +08:00
|
|
|
#endif
|
2017-10-15 22:31:53 +08:00
|
|
|
thread->sig_vectors = RT_NULL;
|
|
|
|
thread->si_list = RT_NULL;
|
|
|
|
#endif
|
|
|
|
|
2018-07-30 11:12:12 +08:00
|
|
|
#ifdef RT_USING_LWP
|
|
|
|
thread->lwp = RT_NULL;
|
|
|
|
#endif
|
|
|
|
|
2017-09-15 11:02:24 +08:00
|
|
|
RT_OBJECT_HOOK_CALL(rt_thread_inited_hook, (thread));
|
2017-04-09 19:12:53 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
return RT_EOK;
|
2009-07-03 06:48:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @addtogroup Thread
|
|
|
|
*/
|
|
|
|
|
2016-08-19 10:18:38 +08:00
|
|
|
/**@{*/
|
2009-07-03 06:48:23 +08:00
|
|
|
|
|
|
|
/**
|
2010-11-29 08:04:55 +08:00
|
|
|
* This function will initialize a thread, normally it's used to initialize a
|
|
|
|
* static thread object.
|
2009-07-03 06:48:23 +08:00
|
|
|
*
|
|
|
|
* @param thread the static thread object
|
|
|
|
* @param name the name of thread, which shall be unique
|
|
|
|
* @param entry the entry function of thread
|
|
|
|
* @param parameter the parameter of thread enter function
|
|
|
|
* @param stack_start the start address of thread stack
|
|
|
|
* @param stack_size the size of thread stack
|
|
|
|
* @param priority the priority of thread
|
|
|
|
* @param tick the time slice if there are same priority thread
|
|
|
|
*
|
2010-11-29 08:04:55 +08:00
|
|
|
* @return the operation status, RT_EOK on OK, -RT_ERROR on error
|
2009-07-03 06:48:23 +08:00
|
|
|
*/
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_err_t rt_thread_init(struct rt_thread *thread,
|
2012-12-21 16:48:30 +08:00
|
|
|
const char *name,
|
|
|
|
void (*entry)(void *parameter),
|
|
|
|
void *parameter,
|
|
|
|
void *stack_start,
|
|
|
|
rt_uint32_t stack_size,
|
|
|
|
rt_uint8_t priority,
|
|
|
|
rt_uint32_t tick)
|
2009-07-03 06:48:23 +08:00
|
|
|
{
|
2012-12-21 16:48:30 +08:00
|
|
|
/* thread check */
|
|
|
|
RT_ASSERT(thread != RT_NULL);
|
|
|
|
RT_ASSERT(stack_start != RT_NULL);
|
|
|
|
|
|
|
|
/* init thread object */
|
|
|
|
rt_object_init((rt_object_t)thread, RT_Object_Class_Thread, name);
|
|
|
|
|
|
|
|
return _rt_thread_init(thread,
|
|
|
|
name,
|
|
|
|
entry,
|
|
|
|
parameter,
|
|
|
|
stack_start,
|
|
|
|
stack_size,
|
|
|
|
priority,
|
|
|
|
tick);
|
2009-07-03 06:48:23 +08:00
|
|
|
}
|
2012-08-27 09:21:57 +08:00
|
|
|
RTM_EXPORT(rt_thread_init);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* This function will return self thread object
|
|
|
|
*
|
|
|
|
* @return the self thread object
|
|
|
|
*/
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_thread_t rt_thread_self(void)
|
2009-07-03 06:48:23 +08:00
|
|
|
{
|
2018-11-22 14:40:43 +08:00
|
|
|
#ifdef RT_USING_SMP
|
|
|
|
rt_base_t lock;
|
|
|
|
rt_thread_t self;
|
|
|
|
|
|
|
|
lock = rt_hw_local_irq_disable();
|
|
|
|
self = rt_cpu_self()->current_thread;
|
|
|
|
rt_hw_local_irq_enable(lock);
|
|
|
|
return self;
|
|
|
|
#else
|
|
|
|
extern rt_thread_t rt_current_thread;
|
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
return rt_current_thread;
|
2018-11-22 14:40:43 +08:00
|
|
|
#endif
|
2009-07-03 06:48:23 +08:00
|
|
|
}
|
2012-08-27 09:21:57 +08:00
|
|
|
RTM_EXPORT(rt_thread_self);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* This function will start a thread and put it to system ready queue
|
|
|
|
*
|
|
|
|
* @param thread the thread to be started
|
|
|
|
*
|
2010-11-29 08:04:55 +08:00
|
|
|
* @return the operation status, RT_EOK on OK, -RT_ERROR on error
|
2009-07-03 06:48:23 +08:00
|
|
|
*/
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_err_t rt_thread_startup(rt_thread_t thread)
|
2009-07-03 06:48:23 +08:00
|
|
|
{
|
2012-12-21 16:48:30 +08:00
|
|
|
/* thread check */
|
|
|
|
RT_ASSERT(thread != RT_NULL);
|
2017-10-15 22:31:53 +08:00
|
|
|
RT_ASSERT((thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_INIT);
|
2018-07-11 18:16:39 +08:00
|
|
|
RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* set current priority to init priority */
|
|
|
|
thread->current_priority = thread->init_priority;
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* calculate priority attribute */
|
2009-07-03 06:48:23 +08:00
|
|
|
#if RT_THREAD_PRIORITY_MAX > 32
|
2012-12-21 16:48:30 +08:00
|
|
|
thread->number = thread->current_priority >> 3; /* 5bit */
|
|
|
|
thread->number_mask = 1L << thread->number;
|
|
|
|
thread->high_mask = 1L << (thread->current_priority & 0x07); /* 3bit */
|
2009-07-03 06:48:23 +08:00
|
|
|
#else
|
2012-12-21 16:48:30 +08:00
|
|
|
thread->number_mask = 1L << thread->current_priority;
|
2009-07-03 06:48:23 +08:00
|
|
|
#endif
|
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
RT_DEBUG_LOG(RT_DEBUG_THREAD, ("startup a thread:%s with priority:%d\n",
|
2012-12-20 15:25:19 +08:00
|
|
|
thread->name, thread->init_priority));
|
2012-12-21 16:48:30 +08:00
|
|
|
/* change thread stat */
|
|
|
|
thread->stat = RT_THREAD_SUSPEND;
|
|
|
|
/* then resume it */
|
|
|
|
rt_thread_resume(thread);
|
|
|
|
if (rt_thread_self() != RT_NULL)
|
|
|
|
{
|
|
|
|
/* do a scheduling */
|
|
|
|
rt_schedule();
|
|
|
|
}
|
|
|
|
|
|
|
|
return RT_EOK;
|
2009-07-03 06:48:23 +08:00
|
|
|
}
|
2012-08-27 09:21:57 +08:00
|
|
|
RTM_EXPORT(rt_thread_startup);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
|
|
|
/**
|
2010-11-29 08:04:55 +08:00
|
|
|
* This function will detach a thread. The thread object will be removed from
|
|
|
|
* thread queue and detached/deleted from system object management.
|
2009-07-03 06:48:23 +08:00
|
|
|
*
|
|
|
|
* @param thread the thread to be deleted
|
|
|
|
*
|
2010-11-29 08:04:55 +08:00
|
|
|
* @return the operation status, RT_EOK on OK, -RT_ERROR on error
|
2009-07-03 06:48:23 +08:00
|
|
|
*/
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_err_t rt_thread_detach(rt_thread_t thread)
|
2009-07-03 06:48:23 +08:00
|
|
|
{
|
2012-12-21 16:48:30 +08:00
|
|
|
rt_base_t lock;
|
2010-11-12 18:16:33 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* thread check */
|
|
|
|
RT_ASSERT(thread != RT_NULL);
|
2018-07-11 18:16:39 +08:00
|
|
|
RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
|
|
|
|
RT_ASSERT(rt_object_is_systemobject((rt_object_t)thread));
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2017-10-15 22:31:53 +08:00
|
|
|
if ((thread->stat & RT_THREAD_STAT_MASK) != RT_THREAD_INIT)
|
2017-04-10 09:53:45 +08:00
|
|
|
{
|
|
|
|
/* remove from schedule */
|
|
|
|
rt_schedule_remove_thread(thread);
|
|
|
|
}
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* release thread timer */
|
|
|
|
rt_timer_detach(&(thread->thread_timer));
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* change stat */
|
|
|
|
thread->stat = RT_THREAD_CLOSE;
|
2010-11-12 18:16:33 +08:00
|
|
|
|
2019-02-14 13:45:25 +08:00
|
|
|
if ((rt_object_is_systemobject((rt_object_t)thread) == RT_TRUE) &&
|
|
|
|
thread->cleanup == RT_NULL)
|
|
|
|
{
|
|
|
|
rt_object_detach((rt_object_t)thread);
|
|
|
|
}
|
|
|
|
else
|
2012-12-21 16:48:30 +08:00
|
|
|
{
|
|
|
|
/* disable interrupt */
|
|
|
|
lock = rt_hw_interrupt_disable();
|
|
|
|
/* insert to defunct thread list */
|
|
|
|
rt_list_insert_after(&rt_thread_defunct, &(thread->tlist));
|
|
|
|
/* enable interrupt */
|
|
|
|
rt_hw_interrupt_enable(lock);
|
|
|
|
}
|
2010-11-12 18:16:33 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
return RT_EOK;
|
2009-07-03 06:48:23 +08:00
|
|
|
}
|
2012-08-27 09:21:57 +08:00
|
|
|
RTM_EXPORT(rt_thread_detach);
|
|
|
|
|
2009-07-03 06:48:23 +08:00
|
|
|
#ifdef RT_USING_HEAP
|
2012-01-09 19:52:03 +08:00
|
|
|
/**
|
|
|
|
* This function will create a thread object and allocate thread object memory
|
|
|
|
* and stack.
|
|
|
|
*
|
|
|
|
* @param name the name of thread, which shall be unique
|
|
|
|
* @param entry the entry function of thread
|
|
|
|
* @param parameter the parameter of thread enter function
|
|
|
|
* @param stack_size the size of thread stack
|
|
|
|
* @param priority the priority of thread
|
|
|
|
* @param tick the time slice if there are same priority thread
|
|
|
|
*
|
|
|
|
* @return the created thread object
|
|
|
|
*/
|
|
|
|
rt_thread_t rt_thread_create(const char *name,
|
2012-12-21 16:58:17 +08:00
|
|
|
void (*entry)(void *parameter),
|
|
|
|
void *parameter,
|
|
|
|
rt_uint32_t stack_size,
|
|
|
|
rt_uint8_t priority,
|
|
|
|
rt_uint32_t tick)
|
2012-01-09 19:52:03 +08:00
|
|
|
{
|
2012-12-21 16:48:30 +08:00
|
|
|
struct rt_thread *thread;
|
|
|
|
void *stack_start;
|
|
|
|
|
|
|
|
thread = (struct rt_thread *)rt_object_allocate(RT_Object_Class_Thread,
|
|
|
|
name);
|
|
|
|
if (thread == RT_NULL)
|
|
|
|
return RT_NULL;
|
|
|
|
|
2013-04-25 14:22:07 +08:00
|
|
|
stack_start = (void *)RT_KERNEL_MALLOC(stack_size);
|
2012-12-21 16:48:30 +08:00
|
|
|
if (stack_start == RT_NULL)
|
|
|
|
{
|
|
|
|
/* allocate stack failure */
|
|
|
|
rt_object_delete((rt_object_t)thread);
|
|
|
|
|
|
|
|
return RT_NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
_rt_thread_init(thread,
|
|
|
|
name,
|
|
|
|
entry,
|
|
|
|
parameter,
|
|
|
|
stack_start,
|
|
|
|
stack_size,
|
|
|
|
priority,
|
|
|
|
tick);
|
|
|
|
|
|
|
|
return thread;
|
2012-01-09 19:52:03 +08:00
|
|
|
}
|
2012-08-27 09:21:57 +08:00
|
|
|
RTM_EXPORT(rt_thread_create);
|
2012-01-09 19:52:03 +08:00
|
|
|
|
2009-07-03 06:48:23 +08:00
|
|
|
/**
|
2010-11-29 08:04:55 +08:00
|
|
|
* This function will delete a thread. The thread object will be removed from
|
2015-10-23 21:54:40 +08:00
|
|
|
* thread queue and deleted from system object management in the idle thread.
|
2009-07-03 06:48:23 +08:00
|
|
|
*
|
|
|
|
* @param thread the thread to be deleted
|
|
|
|
*
|
2010-11-29 08:04:55 +08:00
|
|
|
* @return the operation status, RT_EOK on OK, -RT_ERROR on error
|
2009-07-03 06:48:23 +08:00
|
|
|
*/
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_err_t rt_thread_delete(rt_thread_t thread)
|
2009-07-03 06:48:23 +08:00
|
|
|
{
|
2012-12-21 16:48:30 +08:00
|
|
|
rt_base_t lock;
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* thread check */
|
|
|
|
RT_ASSERT(thread != RT_NULL);
|
2018-07-11 18:16:39 +08:00
|
|
|
RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
|
|
|
|
RT_ASSERT(rt_object_is_systemobject((rt_object_t)thread) == RT_FALSE);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2017-10-15 22:31:53 +08:00
|
|
|
if ((thread->stat & RT_THREAD_STAT_MASK) != RT_THREAD_INIT)
|
2017-04-10 09:53:45 +08:00
|
|
|
{
|
|
|
|
/* remove from schedule */
|
|
|
|
rt_schedule_remove_thread(thread);
|
|
|
|
}
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* release thread timer */
|
|
|
|
rt_timer_detach(&(thread->thread_timer));
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* disable interrupt */
|
|
|
|
lock = rt_hw_interrupt_disable();
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2019-11-12 16:02:24 +08:00
|
|
|
/* change stat */
|
|
|
|
thread->stat = RT_THREAD_CLOSE;
|
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* insert to defunct thread list */
|
|
|
|
rt_list_insert_after(&rt_thread_defunct, &(thread->tlist));
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* enable interrupt */
|
|
|
|
rt_hw_interrupt_enable(lock);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
return RT_EOK;
|
2009-07-03 06:48:23 +08:00
|
|
|
}
|
2012-08-27 09:21:57 +08:00
|
|
|
RTM_EXPORT(rt_thread_delete);
|
2009-07-03 06:48:23 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
2010-11-29 08:04:55 +08:00
|
|
|
* This function will let current thread yield processor, and scheduler will
|
|
|
|
* choose a highest thread to run. After yield processor, the current thread
|
|
|
|
* is still in READY state.
|
2009-07-03 06:48:23 +08:00
|
|
|
*
|
2010-11-29 08:04:55 +08:00
|
|
|
* @return RT_EOK
|
2009-07-03 06:48:23 +08:00
|
|
|
*/
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_err_t rt_thread_yield(void)
|
2009-07-03 06:48:23 +08:00
|
|
|
{
|
2018-11-22 14:40:43 +08:00
|
|
|
rt_schedule();
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
return RT_EOK;
|
2009-07-03 06:48:23 +08:00
|
|
|
}
|
2012-08-27 09:21:57 +08:00
|
|
|
RTM_EXPORT(rt_thread_yield);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* This function will let current thread sleep for some ticks.
|
|
|
|
*
|
|
|
|
* @param tick the sleep ticks
|
|
|
|
*
|
2010-11-29 08:04:55 +08:00
|
|
|
* @return RT_EOK
|
2009-07-03 06:48:23 +08:00
|
|
|
*/
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_err_t rt_thread_sleep(rt_tick_t tick)
|
2009-07-03 06:48:23 +08:00
|
|
|
{
|
2012-12-21 16:48:30 +08:00
|
|
|
register rt_base_t temp;
|
|
|
|
struct rt_thread *thread;
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* set to current thread */
|
2018-11-22 14:40:43 +08:00
|
|
|
thread = rt_thread_self();
|
2012-12-21 16:48:30 +08:00
|
|
|
RT_ASSERT(thread != RT_NULL);
|
2018-07-11 18:16:39 +08:00
|
|
|
RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2018-11-22 14:40:43 +08:00
|
|
|
/* disable interrupt */
|
|
|
|
temp = rt_hw_interrupt_disable();
|
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* suspend thread */
|
|
|
|
rt_thread_suspend(thread);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* reset the timeout of thread timer and start it */
|
|
|
|
rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &tick);
|
|
|
|
rt_timer_start(&(thread->thread_timer));
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* enable interrupt */
|
|
|
|
rt_hw_interrupt_enable(temp);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
rt_schedule();
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* clear error number of this thread to RT_EOK */
|
|
|
|
if (thread->error == -RT_ETIMEOUT)
|
|
|
|
thread->error = RT_EOK;
|
2010-03-21 07:52:47 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
return RT_EOK;
|
2009-07-03 06:48:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This function will let current thread delay for some ticks.
|
|
|
|
*
|
|
|
|
* @param tick the delay ticks
|
|
|
|
*
|
2010-11-29 08:04:55 +08:00
|
|
|
* @return RT_EOK
|
2009-07-03 06:48:23 +08:00
|
|
|
*/
|
|
|
|
rt_err_t rt_thread_delay(rt_tick_t tick)
|
|
|
|
{
|
2012-12-21 16:48:30 +08:00
|
|
|
return rt_thread_sleep(tick);
|
2009-07-03 06:48:23 +08:00
|
|
|
}
|
2012-08-27 09:21:57 +08:00
|
|
|
RTM_EXPORT(rt_thread_delay);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2018-05-12 12:08:47 +08:00
|
|
|
/**
|
|
|
|
* This function will let current thread delay for some milliseconds.
|
|
|
|
*
|
|
|
|
* @param tick the delay time
|
|
|
|
*
|
|
|
|
* @return RT_EOK
|
|
|
|
*/
|
|
|
|
rt_err_t rt_thread_mdelay(rt_int32_t ms)
|
|
|
|
{
|
|
|
|
rt_tick_t tick;
|
|
|
|
|
|
|
|
tick = rt_tick_from_millisecond(ms);
|
|
|
|
|
|
|
|
return rt_thread_sleep(tick);
|
|
|
|
}
|
|
|
|
RTM_EXPORT(rt_thread_mdelay);
|
|
|
|
|
2010-11-29 08:04:55 +08:00
|
|
|
/**
|
|
|
|
* This function will control thread behaviors according to control command.
|
|
|
|
*
|
|
|
|
* @param thread the specified thread to be controlled
|
|
|
|
* @param cmd the control command, which includes
|
2012-12-21 16:48:30 +08:00
|
|
|
* RT_THREAD_CTRL_CHANGE_PRIORITY for changing priority level of thread;
|
2010-11-29 08:04:55 +08:00
|
|
|
* RT_THREAD_CTRL_STARTUP for starting a thread;
|
2018-11-22 14:40:43 +08:00
|
|
|
* RT_THREAD_CTRL_CLOSE for delete a thread;
|
|
|
|
* RT_THREAD_CTRL_BIND_CPU for bind the thread to a CPU.
|
2010-11-29 08:04:55 +08:00
|
|
|
* @param arg the argument of control command
|
|
|
|
*
|
|
|
|
* @return RT_EOK
|
|
|
|
*/
|
2017-10-15 22:31:53 +08:00
|
|
|
rt_err_t rt_thread_control(rt_thread_t thread, int cmd, void *arg)
|
2009-07-03 06:48:23 +08:00
|
|
|
{
|
2012-12-21 16:48:30 +08:00
|
|
|
register rt_base_t temp;
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* thread check */
|
|
|
|
RT_ASSERT(thread != RT_NULL);
|
2018-07-11 18:16:39 +08:00
|
|
|
RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
switch (cmd)
|
|
|
|
{
|
|
|
|
case RT_THREAD_CTRL_CHANGE_PRIORITY:
|
|
|
|
/* disable interrupt */
|
|
|
|
temp = rt_hw_interrupt_disable();
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* for ready thread, change queue */
|
2017-10-15 22:31:53 +08:00
|
|
|
if ((thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_READY)
|
2012-12-21 16:48:30 +08:00
|
|
|
{
|
|
|
|
/* remove thread from schedule queue first */
|
|
|
|
rt_schedule_remove_thread(thread);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* change thread priority */
|
|
|
|
thread->current_priority = *(rt_uint8_t *)arg;
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* recalculate priority attribute */
|
2009-07-03 06:48:23 +08:00
|
|
|
#if RT_THREAD_PRIORITY_MAX > 32
|
2012-12-21 16:48:30 +08:00
|
|
|
thread->number = thread->current_priority >> 3; /* 5bit */
|
|
|
|
thread->number_mask = 1 << thread->number;
|
|
|
|
thread->high_mask = 1 << (thread->current_priority & 0x07); /* 3bit */
|
2009-07-03 06:48:23 +08:00
|
|
|
#else
|
2012-12-21 16:48:30 +08:00
|
|
|
thread->number_mask = 1 << thread->current_priority;
|
2009-07-03 06:48:23 +08:00
|
|
|
#endif
|
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* insert thread to schedule queue again */
|
|
|
|
rt_schedule_insert_thread(thread);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
thread->current_priority = *(rt_uint8_t *)arg;
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* recalculate priority attribute */
|
2009-07-03 06:48:23 +08:00
|
|
|
#if RT_THREAD_PRIORITY_MAX > 32
|
2012-12-21 16:48:30 +08:00
|
|
|
thread->number = thread->current_priority >> 3; /* 5bit */
|
|
|
|
thread->number_mask = 1 << thread->number;
|
|
|
|
thread->high_mask = 1 << (thread->current_priority & 0x07); /* 3bit */
|
2009-07-03 06:48:23 +08:00
|
|
|
#else
|
2012-12-21 16:48:30 +08:00
|
|
|
thread->number_mask = 1 << thread->current_priority;
|
2009-07-03 06:48:23 +08:00
|
|
|
#endif
|
2012-12-21 16:48:30 +08:00
|
|
|
}
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* enable interrupt */
|
|
|
|
rt_hw_interrupt_enable(temp);
|
|
|
|
break;
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
case RT_THREAD_CTRL_STARTUP:
|
|
|
|
return rt_thread_startup(thread);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
|
|
|
#ifdef RT_USING_HEAP
|
2012-12-21 16:48:30 +08:00
|
|
|
case RT_THREAD_CTRL_CLOSE:
|
|
|
|
return rt_thread_delete(thread);
|
2009-07-03 06:48:23 +08:00
|
|
|
#endif
|
|
|
|
|
2018-11-22 14:40:43 +08:00
|
|
|
#ifdef RT_USING_SMP
|
|
|
|
case RT_THREAD_CTRL_BIND_CPU:
|
|
|
|
{
|
|
|
|
rt_uint8_t cpu;
|
|
|
|
|
|
|
|
if ((thread->stat & RT_THREAD_STAT_MASK) != RT_THREAD_INIT)
|
|
|
|
{
|
|
|
|
/* we only support bind cpu before started phase. */
|
|
|
|
return RT_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
cpu = (rt_uint8_t)(size_t)arg;
|
|
|
|
thread->bind_cpu = cpu > RT_CPUS_NR? RT_CPUS_NR : cpu;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif /*RT_USING_SMP*/
|
2012-12-21 16:48:30 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
return RT_EOK;
|
2009-07-03 06:48:23 +08:00
|
|
|
}
|
2012-08-27 09:21:57 +08:00
|
|
|
RTM_EXPORT(rt_thread_control);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* This function will suspend the specified thread.
|
|
|
|
*
|
|
|
|
* @param thread the thread to be suspended
|
|
|
|
*
|
2010-11-29 08:04:55 +08:00
|
|
|
* @return the operation status, RT_EOK on OK, -RT_ERROR on error
|
2009-07-03 06:48:23 +08:00
|
|
|
*
|
2010-11-29 08:04:55 +08:00
|
|
|
* @note if suspend self thread, after this function call, the
|
|
|
|
* rt_schedule() must be invoked.
|
2009-07-03 06:48:23 +08:00
|
|
|
*/
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_err_t rt_thread_suspend(rt_thread_t thread)
|
2009-07-03 06:48:23 +08:00
|
|
|
{
|
2019-01-13 11:23:08 +08:00
|
|
|
register rt_base_t stat;
|
2012-12-21 16:48:30 +08:00
|
|
|
register rt_base_t temp;
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* thread check */
|
|
|
|
RT_ASSERT(thread != RT_NULL);
|
2018-07-11 18:16:39 +08:00
|
|
|
RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread suspend: %s\n", thread->name));
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2019-01-13 11:23:08 +08:00
|
|
|
stat = thread->stat & RT_THREAD_STAT_MASK;
|
|
|
|
if ((stat != RT_THREAD_READY) && (stat != RT_THREAD_RUNNING))
|
2012-12-21 16:48:30 +08:00
|
|
|
{
|
2018-03-01 13:36:22 +08:00
|
|
|
RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread suspend: thread disorder, 0x%2x\n",
|
2012-12-20 15:25:19 +08:00
|
|
|
thread->stat));
|
2012-12-21 16:48:30 +08:00
|
|
|
return -RT_ERROR;
|
|
|
|
}
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* disable interrupt */
|
|
|
|
temp = rt_hw_interrupt_disable();
|
2019-01-13 11:23:08 +08:00
|
|
|
if (stat == RT_THREAD_RUNNING)
|
|
|
|
{
|
|
|
|
/* not suspend running status thread on other core */
|
|
|
|
RT_ASSERT(thread == rt_thread_self());
|
|
|
|
}
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* change thread stat */
|
|
|
|
rt_schedule_remove_thread(thread);
|
2019-01-13 11:23:08 +08:00
|
|
|
thread->stat = RT_THREAD_SUSPEND | (thread->stat & ~RT_THREAD_STAT_MASK);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2014-03-11 14:19:24 +08:00
|
|
|
/* stop thread timer anyway */
|
|
|
|
rt_timer_stop(&(thread->thread_timer));
|
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* enable interrupt */
|
|
|
|
rt_hw_interrupt_enable(temp);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2017-09-15 11:02:24 +08:00
|
|
|
RT_OBJECT_HOOK_CALL(rt_thread_suspend_hook, (thread));
|
2012-12-21 16:48:30 +08:00
|
|
|
return RT_EOK;
|
2009-07-03 06:48:23 +08:00
|
|
|
}
|
2012-08-27 09:21:57 +08:00
|
|
|
RTM_EXPORT(rt_thread_suspend);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* This function will resume a thread and put it to system ready queue.
|
|
|
|
*
|
|
|
|
* @param thread the thread to be resumed
|
|
|
|
*
|
2010-11-29 08:04:55 +08:00
|
|
|
* @return the operation status, RT_EOK on OK, -RT_ERROR on error
|
2009-07-03 06:48:23 +08:00
|
|
|
*/
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_err_t rt_thread_resume(rt_thread_t thread)
|
2009-07-03 06:48:23 +08:00
|
|
|
{
|
2012-12-21 16:48:30 +08:00
|
|
|
register rt_base_t temp;
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* thread check */
|
|
|
|
RT_ASSERT(thread != RT_NULL);
|
2018-07-11 18:16:39 +08:00
|
|
|
RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread resume: %s\n", thread->name));
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2017-10-15 22:31:53 +08:00
|
|
|
if ((thread->stat & RT_THREAD_STAT_MASK) != RT_THREAD_SUSPEND)
|
2012-12-21 16:48:30 +08:00
|
|
|
{
|
|
|
|
RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread resume: thread disorder, %d\n",
|
2012-12-20 15:25:19 +08:00
|
|
|
thread->stat));
|
2011-06-12 18:01:48 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
return -RT_ERROR;
|
|
|
|
}
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* disable interrupt */
|
|
|
|
temp = rt_hw_interrupt_disable();
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* remove from suspend list */
|
|
|
|
rt_list_remove(&(thread->tlist));
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2013-09-26 15:52:02 +08:00
|
|
|
rt_timer_stop(&thread->thread_timer);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* enable interrupt */
|
|
|
|
rt_hw_interrupt_enable(temp);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* insert to schedule ready list */
|
|
|
|
rt_schedule_insert_thread(thread);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2017-09-15 11:02:24 +08:00
|
|
|
RT_OBJECT_HOOK_CALL(rt_thread_resume_hook, (thread));
|
2012-12-21 16:48:30 +08:00
|
|
|
return RT_EOK;
|
2009-07-03 06:48:23 +08:00
|
|
|
}
|
2012-08-27 09:21:57 +08:00
|
|
|
RTM_EXPORT(rt_thread_resume);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
|
|
|
/**
|
2010-11-29 08:04:55 +08:00
|
|
|
* This function is the timeout function for thread, normally which is invoked
|
2012-01-31 20:17:47 +08:00
|
|
|
* when thread is timeout to wait some resource.
|
2009-07-03 06:48:23 +08:00
|
|
|
*
|
|
|
|
* @param parameter the parameter of thread timeout function
|
|
|
|
*/
|
2011-09-21 11:56:42 +08:00
|
|
|
void rt_thread_timeout(void *parameter)
|
2009-07-03 06:48:23 +08:00
|
|
|
{
|
2012-12-21 16:48:30 +08:00
|
|
|
struct rt_thread *thread;
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
thread = (struct rt_thread *)parameter;
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* thread check */
|
|
|
|
RT_ASSERT(thread != RT_NULL);
|
2017-10-15 22:31:53 +08:00
|
|
|
RT_ASSERT((thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND);
|
2018-07-11 18:16:39 +08:00
|
|
|
RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* set error number */
|
|
|
|
thread->error = -RT_ETIMEOUT;
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* remove from suspend list */
|
|
|
|
rt_list_remove(&(thread->tlist));
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* insert to schedule ready list */
|
|
|
|
rt_schedule_insert_thread(thread);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2012-12-21 16:48:30 +08:00
|
|
|
/* do schedule */
|
|
|
|
rt_schedule();
|
2009-07-03 06:48:23 +08:00
|
|
|
}
|
2012-08-27 09:21:57 +08:00
|
|
|
RTM_EXPORT(rt_thread_timeout);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* This function will find the specified thread.
|
|
|
|
*
|
|
|
|
* @param name the name of thread finding
|
|
|
|
*
|
2010-11-29 08:04:55 +08:00
|
|
|
* @return the found thread
|
|
|
|
*
|
|
|
|
* @note please don't invoke this function in interrupt status.
|
2009-07-03 06:48:23 +08:00
|
|
|
*/
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_thread_t rt_thread_find(char *name)
|
2009-07-03 06:48:23 +08:00
|
|
|
{
|
2012-12-21 16:48:30 +08:00
|
|
|
struct rt_object_information *information;
|
|
|
|
struct rt_object *object;
|
|
|
|
struct rt_list_node *node;
|
|
|
|
|
|
|
|
/* enter critical */
|
|
|
|
if (rt_thread_self() != RT_NULL)
|
|
|
|
rt_enter_critical();
|
|
|
|
|
|
|
|
/* try to find device object */
|
2017-12-12 07:36:37 +08:00
|
|
|
information = rt_object_get_information(RT_Object_Class_Thread);
|
|
|
|
RT_ASSERT(information != RT_NULL);
|
2012-12-21 16:48:30 +08:00
|
|
|
for (node = information->object_list.next;
|
|
|
|
node != &(information->object_list);
|
|
|
|
node = node->next)
|
|
|
|
{
|
|
|
|
object = rt_list_entry(node, struct rt_object, list);
|
|
|
|
if (rt_strncmp(object->name, name, RT_NAME_MAX) == 0)
|
|
|
|
{
|
|
|
|
/* leave critical */
|
|
|
|
if (rt_thread_self() != RT_NULL)
|
|
|
|
rt_exit_critical();
|
|
|
|
|
|
|
|
return (rt_thread_t)object;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* leave critical */
|
|
|
|
if (rt_thread_self() != RT_NULL)
|
|
|
|
rt_exit_critical();
|
|
|
|
|
|
|
|
/* not found */
|
|
|
|
return RT_NULL;
|
2009-07-03 06:48:23 +08:00
|
|
|
}
|
2012-08-27 09:21:57 +08:00
|
|
|
RTM_EXPORT(rt_thread_find);
|
2009-07-03 06:48:23 +08:00
|
|
|
|
2016-08-19 10:18:38 +08:00
|
|
|
/**@}*/
|