rtthread："rt_thread"线程
1 微处理器系统
随着产品功能的增多，裸机系统不能够满足产品需求，引入RTOS实时操作系统的多线程管理，可以增加程序的稳定性逻辑性，便于管理；
2 rtos系统启动
正常的系统都是从main函数中启动，那么对于rtos而言。它是如何启动的呢？
rtos使用了keil编译器的打补丁功能，将thread启动之前的初始化放在了打补丁函数中来初始化，初始化完毕之后调度启动执行；
//components.c
extern int $Super$$main(void);
/* re-define main function */
int $Sub$$main(void)
{
rt_hw_interrupt_disable();
rtthread_startup();
return 0;
}
//这是main函数的补丁操作范围
int rtthread_startup(void)
{
rt_hw_interrupt_disable();
rt_hw_board_init(); //NOTE: please initialize heap inside board initialization
//rt_show_version();
rt_system_timer_init(); //system:rt_timer_list
rt_system_scheduler_init(); //system:rt_thread_priority_table
#ifdef RT_USING_SIGNALS
rt_system_signal_init();
#endif
rt_application_init(); //main_thread >>main_thread_entry
rt_system_timer_thread_init(); //timer_thread >>rt_thread_timer_entry
rt_thread_idle_init(); //idle >>rt_thread_idle_entry
rt_system_scheduler_start(); //启动调度函数switch_to汇编;
/* never reach here */
return 0;
}void rt_application_init(void)
{
rt_thread_t tid;
#ifdef RT_USING_HEAP
tid = rt_thread_create("main", main_thread_entry, RT_NULL,
RT_MAIN_THREAD_STACK_SIZE, RT_THREAD_PRIORITY_MAX / 3, 20);
RT_ASSERT(tid != RT_NULL);
#else
rt_err_t result;
tid = &main_thread;
result = rt_thread_init(tid, "main", main_thread_entry, RT_NULL,
main_stack, sizeof(main_stack), RT_THREAD_PRIORITY_MAX / 3, 20);
RT_ASSERT(result == RT_EOK);
/* if not define RT_USING_HEAP, using to eliminate the warning */
(void)result;
#endif
rt_thread_startup(tid);//将"main"线程挂载到优先级表上；优先级=RT_THREAD_PRIORITY_MAX / 3;
}void main_thread_entry(void *parameter)
{
extern int main(void);
extern int $Super$$main(void);
rt_components_init();
/* invoke system main function */
#if defined (__CC_ARM)
$Super$$main(); //回调main函数；
#elif defined(__ICCARM__) || defined(__GNUC__)
main();
#endif
}3 线程 thread
rtos启动完毕之后，我们就可以在main函数中初始化应用层线程了；那什么是线程呢？
线程是以功能划分的程序单元，该程序单元的所有参数囊括在唯一对应的线程结构体中；thread在其他rtos中也被称为task；
3.1 线程结构体 rt_thread
线程结构体存储当前线程的所有参数；对于线程的架构理解可以以线程结构体作为线索来追踪；
//rtdef.h
struct rt_thread
{
/* rt object */
char name[RT_NAME_MAX]; /**< the name of thread */
rt_uint8_t type; /**< type of object */
rt_uint8_t flags; /**< thread's flags */
#ifdef RT_USING_MODULE
void *module_id; /**< id of application module */
#endif
rt_list_t list; /**< the object list */
rt_list_t tlist; /**< the thread list */
/* stack point and entry */
void *sp; /**< stack point */
void *entry; /**< entry */
void *parameter; /**< parameter */
void *stack_addr; /**< stack address */
rt_uint32_t stack_size; /**< stack size */
/* error code */
rt_err_t error; /**< error code */
rt_uint8_t stat; /**< thread status */
/* priority */
rt_uint8_t current_priority; /**< current priority */
rt_uint8_t init_priority; /**< initialized priority */
#if RT_THREAD_PRIORITY_MAX > 32
rt_uint8_t number;
rt_uint8_t high_mask;
#endif
rt_uint32_t number_mask;
#if defined(RT_USING_EVENT)
/* thread event */
rt_uint32_t event_set;
rt_uint8_t event_info;
#endif
#if defined(RT_USING_SIGNALS)
rt_sigset_t sig_pending; /**< the pending signals */
rt_sigset_t sig_mask; /**< the mask bits of signal */
void *sig_ret; /**< the return stack pointer from signal */
rt_sighandler_t *sig_vectors; /**< vectors of signal handler */
void *si_list; /**< the signal infor list */
#endif
rt_ubase_t init_tick; /**< thread's initialized tick */
rt_ubase_t remaining_tick; /**< remaining tick */
struct rt_timer thread_timer; /**< built-in thread timer */
void (*cleanup)(struct rt_thread *tid); /**< cleanup function when thread exit */
rt_uint32_t user_data; /**< private user data beyond this thread */
};
typedef struct rt_thread *rt_thread_t;3.2 对象 rt_object
对象是对线程的各类数据结构的统称；
可以通过容器对象来判断malloc对象分配；但是封装后的数据结构可以挂载到容器上进行统一管理；至于统一管理有啥用还没凸显出来先放着；
//rtdef.h
struct rt_object
{
char name[RT_NAME_MAX]; /**< name of kernel object */
rt_uint8_t type; /**< type of kernel object */
rt_uint8_t flag; /**< flag of kernel object */
#ifdef RT_USING_MODULE
void *module_id; /**< id of application module */
#endif
rt_list_t list; /**< list node of kernel object */
};
typedef struct rt_object *rt_object_t; /**< Type for kernel objects. */
//rt_object_t->type的取值;
enum rt_object_class_type
{
RT_Object_Class_Thread = 0, /* 对象是线程 */
RT_Object_Class_Semaphore, /* 对象是信号量 */
RT_Object_Class_Mutex, /* 对象是互斥量 */
RT_Object_Class_Event, /* 对象是事件 */
RT_Object_Class_MailBox, /* 对象是邮箱 */
RT_Object_Class_MessageQueue, /* 对象是消息队列 */
RT_Object_Class_MemHeap, /* 对象是内存堆 */
RT_Object_Class_MemPool, /* 对象是内存池 */
RT_Object_Class_Device, /* 对象是设备 */
RT_Object_Class_Timer, /* 对象是定时器 */
RT_Object_Class_Module, /* 对象是模块 */
RT_Object_Class_Unknown, /* 对象未知 */
RT_Object_Class_Static = 0x80 /* 对象是静态对象 */
};3.2.1 容器
容器是一个可以寻址rtos系统全部对象的数组；
每个对象在初始化完自己的结构体之后，就顺便把自己挂载到容器对应的数据结构下；
//容器对象结构体 rtdef.h
struct rt_object_information
{
enum rt_object_class_type type; //对象的数据类型
rt_list_t object_list; //该数据类型挂载list的链表头
rt_size_t object_size; //该object struct结构体大小
};
//容器对象类型 object.c
enum rt_object_info_type
{
RT_Object_Info_Thread = 0, //线程对象
#ifdef RT_USING_SEMAPHORE
RT_Object_Info_Semaphore, //信号量对象
#endif
//省略...#ifdef ...#endif
#ifdef RT_USING_MODULE
RT_Object_Info_Module, //模块对象
#endif
RT_Object_Info_Unknown, //对象未知
};
//容器数组 object.c
//下面这行define是用自身地址初始化了容器链表头;
#define _OBJ_CONTAINER_LIST_INIT(c) {&(rt_object_container[c].object_list), &(rt_object_container[c].object_list)}
static struct rt_object_information rt_object_container[RT_Object_Info_Unknown] =
{
{
RT_Object_Class_Thread,
_OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Thread),
sizeof(struct rt_thread)
},
#ifdef RT_USING_SEMAPHORE
{
RT_Object_Class_Semaphore,
_OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Semaphore),
sizeof(struct rt_semaphore)
},
#endif
//#ifdef .......
#ifdef RT_USING_MODULE
{
RT_Object_Class_Module,
_OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Module),
sizeof(struct rt_module)
},
#endif
};3.3 tlist节点
tlist节点用来将线程挂载到线程就绪优先级表上等待执行，或挂载到系统定时器链表上等待延时到期；
////rtdef.h 注意rt_list_t的第一个节点不是prev，而是next;
struct rt_list_node
{
struct rt_list_node *next;
struct rt_list_node *prev;
};
typedef struct rt_list_node rt_list_t;3.3.1 节点地址反推结构体首地址
//rtservice.h 已知一个结构体里面的节点地址，反推出该节点所在的结构体首地址
#define rt_container_of(ptr, type, member) ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member)))
#define rt_list_entry(node, type, member) rt_container_of(node, type, member)
//简单整理了一下上面的宏变成下面这样方便理解;只有最外层和node的括号可以去，其他括号都有用;
//#define rt_list_entry(node, struct, member) (struct *)( (char *)node - (unsigned long)( &((struct *)0)->member ) )
/***
1.
#define 默认换行符为结束define，通过\连接符来连接两行为一个define；
2.
to_thread = rt_list_entry(rt_thread_priority_table[0].next, struct rt_thread, tlist);
= ( (rt_thread *)((char *)rt_thread_priority_table[0].next - (unsigned long)(&((rt_thread *)0)->tlist)) )
(unsigned long)(&((rt_thread *)0)->tlist))：定义一个rt_thread结构体，初始地址赋值为0，那么&(rt_thread->tlist)就是tlist在结构体中的偏移地址；
node地址&(rt_thread_priority_table[0].next) 减去node的偏移地址，就得到了该node所在的线程结构体初始地址，即存储 *sp 的地址；
3.
所有类型的指针都是32位的，用来存储地址，关于这里为什么把指针类型强制转换成char*，因为指针的自加加加的是所指向数据类型的地址宽度；
***/3.4 线程栈 stack
线程栈存储该线程的寄存器状态、栈参数；通常是一段内存空间或全局数组；
//main.c 静态分配； 直接定义了线程栈数组；
rt_uint8_t rt_flag1_thread_stack[512];
//thread.c 动态分配； 在rt_thread_create()函数中，通过RT_KERNEL_MALLOC()函数来分配线程栈的动态内存；
stack_start = (void *)RT_KERNEL_MALLOC(stack_size);3.4.1 stack_frame 通用寄存器
线程栈栈底是stack_frame通用寄存器结构体 ，存储内核通用寄存器组的参数；栈底高地址、栈顶低地址；
//cpuport.c
struct stack_frame
{
/* r4 ~ r11 register 异常发生时需手动保存的寄存器 */
rt_uint32_t r4;
rt_uint32_t r5;
rt_uint32_t r6;
rt_uint32_t r7;
rt_uint32_t r8;
rt_uint32_t r9;
rt_uint32_t r10;
rt_uint32_t r11;
struct exception_stack_frame exception_stack_frame;
};
struct exception_stack_frame
{
/* 异常发生时自动保存的寄存器 */
rt_uint32_t r0;
rt_uint32_t r1;
rt_uint32_t r2;
rt_uint32_t r3;
rt_uint32_t r12;
rt_uint32_t lr;
rt_uint32_t pc;
rt_uint32_t psr;
};4 thread 初始化
对线程的初始化即对线程结构体的初始化；
本小节两种方式虽然内存分配方式不同，但是均调用_rt_thread_init( )；具体见后一节；
4.1 静态内存分配
以全局变量的方式来分配线程内存，内存编译器编译的时候就存在，占用空间；
rt_thread_init( )
//main.c
static rt_uint8_t led0_blink_entry_stack[RT_MAIN_THREAD_STACK_SIZE];
struct rt_thread led0_blink_thread;
int main(void)
{
rt_thread_init(&led0_blink_thread,
"led0_blink",
led0_blink_entry,
RT_NULL,
led0_blink_entry_stack,
sizeof(led0_blink_entry_stack),
2,
50);
}
//thread.c
rt_err_t rt_thread_init(struct rt_thread *thread,
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)
{
/* 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);
}
RTM_EXPORT(rt_thread_init);4.2 动态内存分配
以动态分配的方式来分配线程内存，用完可释放，内存利用率高；
rt_thread_create ( )
//thread.c
rt_thread_t rt_thread_create(const char *name,
void (*entry)(void *parameter),
void *parameter,
rt_uint32_t stack_size,
rt_uint8_t priority,
rt_uint32_t tick)
{
struct rt_thread *thread;
void *stack_start;
//分配rt_object动态内存并初始化;
thread = (struct rt_thread *)rt_object_allocate(RT_Object_Class_Thread, name);
if (thread == RT_NULL)
return RT_NULL;
//分配stack frame的动态内存；
stack_start = (void *)RT_KERNEL_MALLOC(stack_size);
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;
}
RTM_EXPORT(rt_thread_create);5 rt_thread 初始化
5.1 rt_object 初始化
rt_thread 的前一部分即rt_object 对象；首先对其进行初始化；
//object.c
rt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name)
{
struct rt_object *object;
register rt_base_t temp;
struct rt_object_information *information;
RT_DEBUG_NOT_IN_INTERRUPT;
#ifdef RT_USING_MODULE
/*
* get module object information,
* module object should be managed by kernel object container
*/
information = (rt_module_self() != RT_NULL && (type != RT_Object_Class_Module)) ?
&rt_module_self()->module_object[type] : rt_object_get_information(type);
#else
//通过对象的数据结构类型，返回容器数组对象;
information = rt_object_get_information(type);
RT_ASSERT(information != RT_NULL);
#endif
//通过容器获取该数据类型的结构体大小，动态分配内存;
object = (struct rt_object *)RT_KERNEL_MALLOC(information->object_size);
if (object == RT_NULL)
{
/* no memory can be allocated */
return RT_NULL;
}
/* initialize object's parameters */
//2：数据结构类型
object->type = type;
//3：flag标志位
object->flag = 0;
#ifdef RT_USING_MODULE
if (rt_module_self() != RT_NULL)
{
object->flag |= RT_OBJECT_FLAG_MODULE;
}
object->module_id = (void *)rt_module_self();
#endif
//1：对象字符串
rt_strncpy(object->name, name, RT_NAME_MAX);
RT_OBJECT_HOOK_CALL(rt_object_attach_hook, (object));
/* lock interrupt */
temp = rt_hw_interrupt_disable();
//4：对象节点
rt_list_insert_after(&(information->object_list), &(object->list));
/* unlock interrupt */
rt_hw_interrupt_enable(temp);
/* return object */
return object;
}
//object.c
struct rt_object_information *rt_object_get_information(enum rt_object_class_type type)
{
int index;
for (index = 0; index < RT_Object_Info_Unknown; index ++)
if (rt_object_container[index].type == type)
return &rt_object_container[index];
return RT_NULL;
}
//kservice.c 对象字符串拷贝函数
char *rt_strncpy(char *dst, const char *src, rt_ubase_t n)
{
if (n != 0){
char *d = dst;
const char *s = src;
do{
//cae20240104:赋值表达式有返回值,返回值默认为等号右边的赋值变量值;此处为*s的值;
//当src值为0的时候,当n值未递减完的时候,就往dst填充0;这样的话就避免了搬运ram中的杂乱数据;
if ((*d++ = *s++) == 0){
/* NUL pad the remaining n-1 bytes */
while (--n != 0)
*d++ = 0;
break;
}
} while (--n != 0);
}
return (dst);
}5.2 rt_thread 初始化
rt_thread在内存分配完毕之后，都是调用 _rt_thread_init( )对rt_thread进行初始化；
//thread.c
static rt_err_t _rt_thread_init(struct rt_thread *thread,
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)
{
/* init thread list */
rt_list_init(&(thread->tlist));
thread->entry = (void *)entry;
thread->parameter = parameter;
/* stack init */
thread->stack_addr = stack_start;
thread->stack_size = stack_size;
/* init thread stack */
rt_memset(thread->stack_addr, '#', thread->stack_size);
thread->sp = (void *)rt_hw_stack_init(thread->entry, thread->parameter,
(void *)((char *)thread->stack_addr + thread->stack_size - 4),
(void *)rt_thread_exit);
/* priority init */
RT_ASSERT(priority < RT_THREAD_PRIORITY_MAX);
thread->init_priority = priority;
thread->current_priority = priority;
thread->number_mask = 0;
#if RT_THREAD_PRIORITY_MAX > 32
thread->number = 0;
thread->high_mask = 0;
#endif
/* tick init */
thread->init_tick = tick;
thread->remaining_tick = tick;
/* error and flags */
thread->error = RT_EOK;
thread->stat = RT_THREAD_INIT;
/* 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);
#ifdef RT_USING_MODULE
thread->module_id = RT_NULL;
#endif
/* initialize signal */
#ifdef RT_USING_SIGNALS
thread->sig_mask = 0x00;
thread->sig_pending = 0x00;
thread->sig_ret = RT_NULL;
thread->sig_vectors = RT_NULL;
thread->si_list = RT_NULL;
#endif
RT_OBJECT_HOOK_CALL(rt_thread_inited_hook, (thread));
return RT_EOK;
} 
5.3 stack_frame 初始化
在_rt_thread_init( )中初始化rt_thread的时候，会调用rt_hw_stack_init( )对stack_frame进行初始化；
所以等会BLX回原程序的时候是执行lr中的rt_thread_exit()函数吗？那pc指针里存储的原函数地址又是什么用呢？先放着；
lr中存放的是当前entry退出的执行函数入口，pc里存放的是当前entry进入的时候执行的函数入口；。。。我怎么会问这么傻屌的问题；
//cpuport.c 传入的stack_addr = &rt_flag1_thread_stack[0] + sizeof(栈) - 4 ;
rt_uint8_t *rt_hw_stack_init(void *tentry,
void *parameter,
rt_uint8_t *stack_addr,
void *texit)
{
struct stack_frame *stack_frame;
rt_uint8_t *stk;
unsigned long i;
stk = stack_addr + sizeof(rt_uint32_t); //下面这里又加了4; 这里stk指向栈底之外的地址;
stk = (rt_uint8_t *)RT_ALIGN_DOWN((rt_uint32_t)stk, 8); //8字节align，冗余字节dummy;
stk -= sizeof(struct stack_frame); //这里stk移动到了&r4，返回值;
stack_frame = (struct stack_frame *)stk;
/* init all register */
for (i = 0; i < sizeof(struct stack_frame) / sizeof(rt_uint32_t); i ++)
{
((rt_uint32_t *)stack_frame)[i] = 0xdeadbeef;
}
stack_frame->exception_stack_frame.r0 = (unsigned long)parameter; /* r0 : argument 线程函数形参*/
stack_frame->exception_stack_frame.r1 = 0;
stack_frame->exception_stack_frame.r2 = 0;
stack_frame->exception_stack_frame.r3 = 0;
stack_frame->exception_stack_frame.r12 = 0;
stack_frame->exception_stack_frame.lr = (unsigned long)texit; /* lr &rt_thread_exit()地址 */
stack_frame->exception_stack_frame.pc = (unsigned long)tentry; /* entry point, pc 线程函数地址*/
stack_frame->exception_stack_frame.psr = 0x01000000L; /* PSR bit24置1确保返回的是psp*/
/* return task's current stack address */
return stk;
}
//地址对齐，冗余地址字节舍弃;
#define RT_ALIGN_DOWN(addr, align) ((addr) & ~((align) - 1)5.4 定时器初始化
见定时器章节；
5.5 rt_thread_exit退出线程
&rt_thread_exit( ) 的地址已经放入到了lr寄存器中，当线程函数执行完返回的时候就会跳转到rt_thread_exit( )执行；
//thread.c
//if是static rt_object，那么detach rt_object;所以这里并没有对static线程执行什么处理咯?
//else，那么&thread->tlist插入&rt_thread_defunct，等待idle_entry清理;
//当前函数是在线程退出的时候才会执行,所以线程许多都是while(1)不会执行到这里;
void rt_thread_exit(void)
{
struct rt_thread *thread;
register rt_base_t level;
/* get current thread */
thread = rt_current_thread;
/* 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 */
rt_timer_detach(&thread->thread_timer);
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();
}6 注意事项
//这里的结构体对象和结构体指针都声明成了rt_xx_t的形式，不对称；
/************************************************************************/
struct rt_thread{
/*...*/
};
typedef struct rt_thread *rt_thread_t; //声明 rt_thread_t 是结构体指针;
/************************************************************************/
struct rt_list_node{
struct rt_list_node *next;
struct rt_list_node *prev;
};
typedef struct rt_list_node rt_list_t; //声明 rt_list_t 是结构体;
/************************************************************************/
struct rt_object{
/*...*/
};
typedef struct rt_object *rt_object_t; //声明rt_object_t是结构体指针;7 小结
系统是如何从补丁函数启动的；
单个线程函数是如何初始化的，其中的参数psr pc lr r0具体标识；
本文总体满意，还算结构清晰；棒棒哒；
