[RT-Thread 源码分析] 3. 内核对象管理

对象控制块
/**
* Base structure of Kernel object
*/
struct rt_object
{
char       name[RT_NAME_MAX];   // 名称
rt_uint8_t type;                // 内核对象类型
rt_uint8_t flag;                // 内核对象标志

#ifdef RT_USING_MODULE
void      *module_id;           // 模块ID
#endif
rt_list_t  list;                // 内核对象链表节点
};
typedef struct rt_object *rt_object_t;
在内核里，所有对象都由链表组织起来。链表定义如下：
struct rt_list_node
{
struct rt_list_node *next; // 指向下一节点
struct rt_list_node *prev; // 指向前一节点
};
typedef struct rt_list_node rt_list_t;
所有可能派生出来的对象为：
/**
*  The object type can be one of the follows with specific
*  macros enabled:
*  - Thread
*  - Semaphore
*  - Mutex
*  - Event
*  - MailBox
*  - MessageQueue
*  - MemHeap
*  - MemPool
*  - Device
*  - Timer
*  - Module
*  - Unknown
*  - Static
*/
enum rt_object_class_type
{
RT_Object_Class_Thread = 0,     // 线程
#ifdef RT_USING_SEMAPHORE
RT_Object_Class_Semaphore,      // 信号量
#endif
#ifdef RT_USING_MUTEX
RT_Object_Class_Mutex,          // 互斥锁
#endif
#ifdef RT_USING_EVENT
RT_Object_Class_Event,          // 事件
#endif
#ifdef RT_USING_MAILBOX
RT_Object_Class_MailBox,        // 邮箱
#endif
#ifdef RT_USING_MESSAGEQUEUE
RT_Object_Class_MessageQueue,   // 消息队列
#endif
#ifdef RT_USING_MEMHEAP
RT_Object_Class_MemHeap,        // 内存堆
#endif
#ifdef RT_USING_MEMPOOL
RT_Object_Class_MemPool,        // 内存池
#endif
#ifdef RT_USING_DEVICE
RT_Object_Class_Device,         // 设备驱动
#endif
RT_Object_Class_Timer,          // 时钟
#ifdef RT_USING_MODULE
RT_Object_Class_Module,         // 模块
#endif
RT_Object_Class_Unknown,        // 未知内核对象类型
RT_Object_Class_Static = 0x80   // rt-thread以此位标志是否为系统内核对象
};
所有对象又被放置于对象容器中：
/**
* The information of the kernel object
*/
struct rt_object_information
{
enum rt_object_class_type type;          // 内核对象类型
rt_list_t                 object_list;   // 内核对象链表
rt_size_t                 object_size;   // 内核对象所占的大小
};

RTT中,内核对象管理系统是用一个rt_object_information数组来实现的,如下：
#define _OBJ_CONTAINER_LIST_INIT(c)\
// 内核对象容器的链表初始化,这里用一个宏来定义,链表的前一节点和后一节点在初始化时都指向本身所在地址
{&(rt_object_container[c].object_list), &(rt_object_container[c].object_list)}

//内核对象管理系统,这里用rt_object_information数组来实现
struct rt_object_information rt_object_container[RT_Object_Class_Unknown] =
{
/* initialize object container - thread */)},//线程对象信息
{RT_Object_Class_Thread, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_Thread), sizeof(struct rt_thread#ifdef RT_USING_SEMAPHORE
/* initialize object container - semaphore *///信号量对象信息
{RT_Object_Class_Semaphore, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_Semaphore), sizeof(struct rt_semaphore)},
#endif
#ifdef RT_USING_MUTEX
/* initialize object container - mutex *///互斥锁对象信息
{RT_Object_Class_Mutex, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_Mutex), sizeof(struct rt_mutex)},
#endif
#ifdef RT_USING_EVENT
/* initialize object container - event *///事件对象信息
{RT_Object_Class_Event, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_Event), sizeof(struct rt_event)},
#endif
#ifdef RT_USING_MAILBOX
/* initialize object container - mailbox *///邮箱对象信息
{RT_Object_Class_MailBox, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_MailBox), sizeof(struct rt_mailbox)},
#endif
#ifdef RT_USING_MESSAGEQUEUE
/* initialize object container - message queue *///消息队列对象信息
{RT_Object_Class_MessageQueue, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_MessageQueue), sizeof(struct rt_messagequeue)},
#endif
#ifdef RT_USING_MEMHEAP
/* initialize object container - memory heap *///内存堆对象信息
{RT_Object_Class_MemHeap, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_MemHeap), sizeof(struct rt_memheap)},
#endif
#ifdef RT_USING_MEMPOOL
/* initialize object container - memory pool *///内存池对象信息
{RT_Object_Class_MemPool, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_MemPool), sizeof(struct rt_mempool)},
#endif
#ifdef RT_USING_DEVICE
/* initialize object container - device *///设备驱动对象信息
{RT_Object_Class_Device, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_Device), sizeof(struct rt_device)},
#endif
/* initialize object container - timer *///时钟对象信息
{RT_Object_Class_Timer, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_Timer), sizeof(struct rt_timer)},
#ifdef RT_USING_MODULE
/* initialize object container - module *///模块对象信息
{RT_Object_Class_Module, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_Module), sizeof(struct rt_module)},
#endif
};

1. 内核对象初始化
=====
初始化分为静态和动态，区别主要静态是编译时确定，线程栈就在堆栈上，而动态则是运行时确定，其栈在堆上。
/**
* This function will initialize an object and add it to object system
* management.
*
* @param object the specified object to be initialized.
* @param type the object type.
* @param name the object name. In system, the object's name must be unique.
*/
void rt_object_init(struct rt_object         *object,   // 指向已存在的对象指针
enum rt_object_class_type type,     // 对象的类型
const char               *name)     // 对象的名字字符串
{
register rt_base_t temp;
struct rt_object_information *information;      // 对象容器

#ifdef RT_USING_MODULE
/* get module object information */
information = (rt_module_self() != RT_NULL) ?
&rt_module_self()->module_object[type] : &rt_object_container[type];
#else
/* get object information */
// 从对象容器数组中，获取该类对象的链表信息
information = &rt_object_container[type];
#endif

/* initialize object's parameters */

/* set object type to static */
// 将对象置位静态
object->type = type | RT_Object_Class_Static;

/* copy name */
// 复制名字，字符串，并且规定字符串长度
rt_strncpy(object->name, name, RT_NAME_MAX);

RT_OBJECT_HOOK_CALL(rt_object_attach_hook, (object));

/* lock interrupt */
// 禁中断
temp = rt_hw_interrupt_disable();

/* insert object into information object list */
// 将新对象插入当前对象容器中的链表
rt_list_insert_after(&(information->object_list), &(object->list));

/* unlock interrupt */
// 开中断
rt_hw_interrupt_enable(temp);
}

2. 线程脱离
/**
* This function will detach a static object from object system,
* and the memory of static object is not freed.
*
* @param object the specified object to be detached.
*/
void rt_object_detach(rt_object_t object)
{
register rt_base_t temp;

/* object check */
RT_ASSERT(object != RT_NULL);

RT_OBJECT_HOOK_CALL(rt_object_detach_hook, (object));

/* lock interrupt */
temp = rt_hw_interrupt_disable();

/* remove from old list */
// 将对象从链表中删除
// 因为这是静态的对象方法，所以并不是真正的将对象删除，只是将其移除链表
// 其所占的内存空间也不会回收
rt_list_remove(&(object->list));

/* unlock interrupt */
rt_hw_interrupt_enable(temp);
}

3. 动态初始化
=====
#ifdef RT_USING_HEAP
/**
* This function will allocate an object from object system
*
* @param type the type of object
* @param name the object name. In system, the object's name must be unique.
*
* @return object
*/
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_container[type];
#else
/* get object information */
information = &rt_object_container[type];
#endif

object = (struct rt_object *)rt_malloc(information->object_size);
// 按照其所要求的空间在heap上动态分配内存空间
if (object == RT_NULL)
{
/* no memory can be allocated */
return RT_NULL;
}
// 其后的步骤就和静态类似

/* initialize object's parameters */

/* set object type */
object->type = type;

/* set object 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

/* copy name */
rt_strncpy(object->name, name, RT_NAME_MAX);

RT_OBJECT_HOOK_CALL(rt_object_attach_hook, (object));

/* lock interrupt */
temp = rt_hw_interrupt_disable();

/* insert object into information object list */
rt_list_insert_after(&(information->object_list), &(object->list));

/* unlock interrupt */
rt_hw_interrupt_enable(temp);

/* return object */
return object;
}

4. 动态线程删除
=====
/**
* This function will delete an object and release object memory.
*
* @param object the specified object to be deleted.
*/
void rt_object_delete(rt_object_t object)
{
register rt_base_t temp;

/* object check */
RT_ASSERT(object != RT_NULL);
RT_ASSERT(!(object->type & RT_Object_Class_Static));
// 断言，确保不是静态

RT_OBJECT_HOOK_CALL(rt_object_detach_hook, (object));

/* lock interrupt */
temp = rt_hw_interrupt_disable();

/* remove from old list */
// 首先从链表中删除
rt_list_remove(&(object->list));

/* unlock interrupt */
rt_hw_interrupt_enable(temp);

#if defined(RT_USING_MODULE) && defined(RT_USING_SLAB)
if (object->flag & RT_OBJECT_FLAG_MODULE)
rt_module_free((rt_module_t)object->module_id, object);
else
#endif

/* free the memory of object */
// 由于是动态，还需释放其所占的空间
rt_free(object);
}
#endif