lby/mkrtos-real
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

!2 增加thread测试，用户态内存分配增加检测机制，增加新的编译工具链

Browse Source 
Merge pull request !2 from 张正/developer
This commit is contained in:
张正
2022-12-14 15:13:12 +00:00
committed by Gitee
parent f29650397c 1ebf9f0e06
commit f7eaeb9ad9
28 changed files with 278 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
.vscode/launch.json vendored
View File

@@ -4,23 +4,24 @@
"name": "(gdb) 启动",
"type": "cppdbg",
"request": "launch",
"program": "/home/ubuntu/zhangzheng/mkrtos-real/build/mkrtos/mkrtos_real/mkrtos_real.elf",
"program": "/home/zhangzheng/mkrtos-real/build/mkrtos/mkrtos_real/mkrtos_real.elf",
"args": [],
"stopAtEntry": true,
"cwd": "${fileDirname}",
"environment": [],
"externalConsole": false,
"miDebuggerPath": "/home/ubuntu/zhangzheng/mkrtos-real/toolchains/gcc-arm-none-eabi-5_4-2016q3/bin/arm-none-eabi-gdb",
"miDebuggerPath": "/home/zhangzheng/mkrtos-real/toolchains/gcc-arm-none-eabi-5_4-2016q3/bin/arm-none-eabi-gdb",
"miDebuggerServerAddress": "127.0.0.1:3333",
"MIMode": "gdb",
"setupCommands": [
{
"description": "为 gdb 启用整齐打印",
"text": "-enable-pretty-printing -exec add-symbol-file /home/zhangzheng/mkrtos/build/mkrtos/mkrtos_ls/mkrtos_ls.elf 0x8040074",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
]
}
],
"version": "2.0.0"
}
}
// -exec add-symbol-file /home/zhangzheng/mkrtos/build/mkrtos/mkrtos_ls/mkrtos_ls.elf 0x8040074

3
.vscode/settings.json vendored
View File

@@ -68,7 +68,8 @@
"mm.h": "c",
"atomic.h": "c",
"slist.h": "c",
"exec.h": "c"
"exec.h": "c",
"bitset": "c"
},
"cortex-debug.showRTOS": false
}

2
mkrtos_real/device/early_console.c
View File

@@ -80,4 +80,4 @@ static int reg_early_console(void)
console_reg(0);
return 0;
}
INIT_REG(reg_early_console, INIT_TEST_REG);
INIT_REG(reg_early_console, INIT_FUNC_REG);

4
mkrtos_real/device/stm32f205rft6/bk_flash.c
View File

@@ -11,7 +11,7 @@
static uint8_t *bk_cache = (uint8_t *)0x20010000;
#define BK_SIZE 512
#define BK_SIZE 256
#define BK_COUNT (BK_CACHE_SIZE/BK_SIZE)
#define FLASH_BK_CACHE_LEN 2
@@ -50,7 +50,7 @@ static struct file_operations bk_ops = { .open = bk_file_open, .read =
dev_t used_dev_no = BK_FLASH;
#define DEV_NAME "flash"
/**
* ע<EFBFBD><EFBFBD><EFBFBD>豸<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ע<EFBFBD><EFBFBD><EFBFBD>ɹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>豸<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
* 注册设备驱动，注册成功返回设备驱动号
* @return
*/
int32_t bk_flash_init(void) {

1
mkrtos_real/device/stm32f205rft6/bk_ro_flash.c
View File

@@ -51,7 +51,6 @@ static struct file_operations bk_ops = { .open = bk_file_open, .read =
static int32_t ro_bk_flash_init(void) {
if (request_bk_no(BK_RO_FLASH) < 0) {
return -1;
}

2
mkrtos_real/exec/exec.c
View File

@@ -284,7 +284,7 @@ again_alloc:
curr_task->signals[i]._u._sa_handler = SIG_DFL;
}
mem_init(&curr_task->user_head_alloc);
mem_init(&curr_task->user_head_alloc, 1);
mem_heap_add(&curr_task->user_head_alloc, (char *)ram+exec_fi->i.heap_offset - exec_fi->i.data_offset,exec_fi->i.heap_size);
if (curr_task == c_task) {

38
mkrtos_real/inc/config.h
View File

@@ -10,7 +10,7 @@
#include <arch/arch.h>
#include <mkrtos.h>
typedef int (*init_func)(void); //!< 初始化函数
#define SYS_NAME "mkrtos"
#define SYS_VERSION "0.01"
#define SYS_RELEASE "0.01"
@@ -22,6 +22,7 @@
#define SECTION(x) __attribute__((section(x)))
//自动初始化接口
#define INIT_LV0(name) const init_func mkrtos_init_func_##name SECTION(".mkrtos.init.0") = name
#define INIT_LV1(name) const init_func mkrtos_init_func_##name SECTION(".mkrtos.init.1") = name
#define INIT_LV2(name) const init_func mkrtos_init_func_##name SECTION(".mkrtos.init.2") = name
@@ -30,9 +31,40 @@
#define INIT_REG(name, LVL)\
const init_func mkrtos_init_func_##name SECTION(".mkrtos.init."LVL) = name
#define INIT_TEST_REG "3"
#define INIT_TEST_LVL "4"
#define INIT_FUNC_REG "3"
#define INIT_PRE_BOOT "4"
/**
* @brief 初始化调用
*
*/
static inline void mkrtos_init(void){
extern ptr_t _mkrtos_init_start,_mkrtos_init_end;
ptr_t* func_start=(ptr_t*)(&_mkrtos_init_start);
ptr_t* func_stop=(ptr_t*)(&_mkrtos_init_end);
for(;func_start<func_stop;func_start++){
((init_func)(*func_start))();
}
}
//自动测试接口
#define INIT_TEST_REG(name, LVL)\
const init_func mkrtos_init_test_func##name SECTION(".mkrtos.test."LVL) = name
#define INIT_TEST_LVL "5"
/**
* @brief 测试自动调用
*
*/
static inline void mkrtos_test(void){
extern ptr_t _mkrtos_init_test_start,_mkrtos_init_test_end;
ptr_t* func_start=(ptr_t*)(&_mkrtos_init_test_start);
ptr_t* func_stop=(ptr_t*)(&_mkrtos_init_test_end);
for(;func_start<func_stop;func_start++){
((init_func)(*func_start))();
}
}
#define ARCH_INIT() arch_init()

2
mkrtos_real/inc/knl_service.h
View File

@@ -20,6 +20,8 @@ void user_free(void *mem);
void knl_mem_trace(void);
struct mem_heap *knl_mem_get_free(struct mem_heap *next,
int32_t hope_size, uint32_t *ret_addr);
int knl_check_user_ram_mem(void *start_addr, int size);
void knl_check_user_ram_access_exit(void *start_addr, int size, int is_unlock, int is_check);
//
void mkrtos_memcpy(void *dst,void *src,int len);

2
mkrtos_real/inc/mkrtos.h
View File

@@ -88,7 +88,7 @@ static inline int is_power_of_2(int num){
\
}while(0)
typedef int (*init_func)(void); //!< 初始化函数
typedef int (*sys_call_func)(void); //!< 系统调用函数
#endif /* INC_MKRTOS_H_ */

11
mkrtos_real/inc/mkrtos/fs.h
View File

@@ -314,6 +314,17 @@ int bk_file_write(struct inode *ino, struct file *fp, char *buf, int count);
int bK_file_fsync(struct inode *inode, struct file *filp);
int bk_file_release(struct inode *ino, struct file *fp);
// int sys_mknod(const char * filename, int mode, dev_t dev);
// int sys_mkdir(const char * pathname, int mode);
// int32_t sys_open(const char* path,int32_t flags,int32_t mode);
// int sys_write (int fd,uint8_t *buf,uint32_t len);
// int sys_read (int fd,uint8_t *buf,uint32_t len);
// void sys_close(int fp);
// int sys_readdir(unsigned int fd, struct dirent * dirent, uint32_t count);
/**
* @breif: 不同编译器Setion的定义
*/

5
mkrtos_real/inc/mkrtos/sched.h
View File

@@ -139,7 +139,7 @@ typedef struct task {
* @brief 系统任务基础链表，存储不同优先级的链表头
*/
struct sys_task_base_links {
slist_head_t tasks_links;
slist_head_t tasks_links; //!<任务的链表
uint16_t task_count; //!< 任务个数
uint16_t task_ready_count; //!< 就绪任务个数
uint8_t task_priority; //!< 任务的优先级
@@ -160,8 +160,9 @@ struct sys_tasks {
slist_head_t all_tk_list; //!< 所有的任务链表
atomic_t pid_temp; //!< 创建任务分配任务ID使用
uint16_t tasks_count; //!< 系统任务数
atomic_t wait_r; //!< 是否有进程等待释放
uint8_t is_first; //!< 是否首次,是为0，不是为1
uint8_t wait_r; //!< 是否有进程等待释放
uint8_t is_run; //!< 系统是否启动完成
};
//等待链表

11
mkrtos_real/inc/mm.h
View File

@@ -16,11 +16,13 @@
typedef struct mem_heap {
uint32_t magic;
char name[MEM_HEAP_NAME];
union {
char name[MEM_HEAP_NAME];
pid_t pid;
};
struct mem_heap* next;
struct mem_heap* prev;
uint32_t size;
uint16_t blong_user; //!< 属于用户
uint16_t used;
} mem_heap_t;
@@ -30,13 +32,14 @@ typedef struct mem {
struct mem_heap* heap_start; //!< 开始位置
struct mem_heap* heap_end; //!< 结束位置
struct mem_heap* l_heap; //!< 空闲位置
uint16_t blong_user; //!< 属于用户
} mem_t;
void mem_init(mem_t *_this);
void mem_init(mem_t *_this, int is_user);
void mem_free(mem_t *_this, void* mem);
void* mem_alloc(mem_t *_this, uint32_t size);
int mem_heap_add(mem_t *_this, void* mem, uint32_t size);
void* mem_split(void* mem, uint32_t size);
void* mem_split(mem_t *_this, void* mem, uint32_t size);
void* mem_alloc_align(mem_t *_this, uint32_t size, uint32_t align);
void mem_free_align(mem_t *_this, void* f_mem);
size_t mem_get_free_size(mem_t *_this);

4
mkrtos_real/knl/exit.c
View File

@@ -15,7 +15,7 @@
void do_exit(int32_t exitCode) {
//关所有中断
uint32_t t;
kprint("kill pid is %d.\n", get_current_task()->pid);
//kprint("kill pid is %d.\n", get_current_task()->pid);
if (get_current_task()->status == TASK_CLOSED) {
return;
}
@@ -81,7 +81,7 @@ void do_exit(int32_t exitCode) {
// #if MEM_TRACE
// knl_mem_trace();
// #endif
get_sys_tasks_info()->wait_r++;
atomic_inc(&get_sys_tasks_info()->wait_r);
restore_cpu_intr(t);
}
///**

10
mkrtos_real/knl/fs_init.c
View File

@@ -9,21 +9,13 @@
#include <mkrtos/stat.h>
#include <paths.h>
//导入外部的两个函数
extern int sys_mknod(const char * filename, int mode, dev_t dev);
extern int sys_mkdir(const char * pathname, int mode);
int32_t sys_open(const char* path,int32_t flags,int32_t mode);
int sys_write (int fd,uint8_t *buf,uint32_t len);
int sys_readdir(unsigned int fd, struct dirent * dirent, uint32_t count);
void sys_close(int fp);
int sys_read (int fd,uint8_t *buf,uint32_t len);
void fs_init(void){
//创建设备目录
sys_mkdir("/dev",0777);
sys_mkdir("/mnt",0777);
sys_mkdir("/bin",0777);
sys_mkdir("/etc",0777);
sys_mkdir("/tmp",0777);
//null设备
sys_mknod(_PATH_DEVNULL,MK_MODE(S_IFCHR,0777),MKDEV(NULL_MAJOR,0));
sys_mknod("/dev/ro_flash", MK_MODE(S_IFBLK, 0777), MKDEV(BK_RO_FLASH, 0));

11
mkrtos_real/knl/kill.c
View File

@@ -5,7 +5,7 @@
#include <mkrtos/sched.h>
#include <arch/arch.h>
/**
* ɱ<EFBFBD><EFBFBD>ij<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
*
* @param pid
* @param sig
*/
@@ -17,18 +17,17 @@ int32_t do_kill_pid(pid_t pid, int32_t sig) {
if (tmp == get_current_task() && tmp->pid != pid) {
return -ESRCH;
}
//<2F><><EFBFBD><EFBFBD>kill<6C>ź<EFBFBD>
if (sig) {
inner_set_task_sig(tmp, sig);
}
// if(sig) {//<2F><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD>ź<EFBFBD>
// if(sig) {
// inner_set_sig(sig);
// }
restore_cpu_intr(t);
return 0;
}
/**
* ɱ<EFBFBD><EFBFBD>ijһ<EFBFBD><EFBFBD>
*
* @param pgid
* @param sig
* @return
@@ -43,7 +42,7 @@ int32_t do_kill_group(pid_t pgid, int32_t sig) {
if (sig) {
inner_set_task_sig(tmp, sig);
}
// if(sig) {//<2F><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD>ź<EFBFBD>
// if(sig) {
// inner_set_sig(sig);
// }
}
@@ -52,7 +51,7 @@ int32_t do_kill_group(pid_t pgid, int32_t sig) {
return 0;
}
/**
* ɱ<EFBFBD><EFBFBD>ij<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
*
* @param pid
* @param sig
* @return

28
mkrtos_real/knl/knl_service.c
View File

@@ -54,14 +54,34 @@ struct mem_heap *knl_mem_get_free(struct mem_heap *next,
* @param op 0 读写 1 读
* @return int 0 正确，失败
*/
int knl_check_user_mem(void *start_addr, int size, int op)
int knl_check_user_ram_mem(void *start_addr, int size)
{
task_t * curr_task = get_current_task();
mword_t u_addr = TASK_USER_RAM_ADDR(curr_task);
mword_t k_addr = TASK_USER_RAM_SIZE(curr_task);
mword_t s_addr = TASK_USER_RAM_ADDR(curr_task);
mword_t e_addr = s_addr + TASK_USER_RAM_SIZE(curr_task);
if ( (mword_t)start_addr >= s_addr && (mword_t)start_addr < e_addr
&& ((mword_t)start_addr + size) >= s_addr && ((mword_t)start_addr + size) < e_addr
) {
return 0;
}
return -1;
}
void knl_check_user_ram_access_exit(void *start_addr, int size, int is_unlock, int is_check)
{
if (!is_check) {
return;
}
int ret = knl_check_user_ram_mem(start_addr, size);
if (ret < 0) {
if (is_unlock) {
sche_unlock();
}
do_exit(-1);
}
}
// void *user_malloc(uint32_t size,const char* name){

12
mkrtos_real/knl/mkrtos.c
View File

@@ -11,19 +11,7 @@
#include <mm.h>
#include <mkrtos/early_console.h>
extern ptr_t _mkrtos_init_start,_mkrtos_init_end;
/**
* @brief 初始化调用
*
*/
static void mkrtos_init(void){
ptr_t* func_start=(ptr_t*)(&_mkrtos_init_start);
ptr_t* func_stop=(ptr_t*)(&_mkrtos_init_end);
for(;func_start<func_stop;func_start++){
((init_func)(*func_start))();
}
}
/**
* @brief 第一个C函数
*

26
mkrtos_real/knl/mm.c
View File

@@ -9,11 +9,13 @@
#include <mkrtos/sched.h>
#include <mkrtos.h>
#include <assert.h>
#include <knl_service.h>
void mem_init(mem_t *_this) {
void mem_init(mem_t *_this, int is_user) {
_this->heap_start = NULL;
_this->heap_end = NULL;
_this->l_heap = NULL;
_this->blong_user = is_user;
}
/**
* @brief 合并空闲的内存
@@ -23,9 +25,11 @@ static void mem_merge(mem_t *_this, struct mem_heap* mem) {
struct mem_heap* prev_mem;
struct mem_heap* t_mem;
knl_check_user_ram_access_exit(mem, sizeof(struct mem_heap), 1, _this->blong_user);
_this->l_heap = mem;
prev_mem = mem->prev;
for (t_mem = mem; t_mem != _this->heap_end; t_mem = t_mem->next) {
knl_check_user_ram_access_exit(t_mem, sizeof(struct mem_heap), 1, _this->blong_user);
if (prev_mem && prev_mem->used == 0) {
//如果当前没有使用，并且上一个的下一个位置等于当前，则上一个和当前合并
if (t_mem->used == 0 && ((ptr_t)prev_mem + prev_mem->size
@@ -58,6 +62,7 @@ void mem_free(mem_t *_this, void* mem) {
//#endif
sche_lock();
m_mem = (struct mem_heap*)((ptr_t)mem - MEM_HEAP_STRUCT_SIZE);
knl_check_user_ram_access_exit(m_mem, sizeof(struct mem_heap), 1, _this->blong_user);
MKRTOS_ASSERT(m_mem->magic == MAGIC_NUM);
if (!m_mem->used) {
sche_unlock();
@@ -73,7 +78,7 @@ void mem_free(mem_t *_this, void* mem) {
/**
* @brief 划分内存
*/
void* mem_split(void* mem, uint32_t size) {
void* mem_split(mem_t *_this, void* mem, uint32_t size) {
struct mem_heap* t_mem;
struct mem_heap* r_mem;
if (!mem) {
@@ -81,12 +86,14 @@ void* mem_split(void* mem, uint32_t size) {
}
sche_lock();
t_mem = (struct mem_heap*)((ptr_t)mem - MEM_HEAP_STRUCT_SIZE);
knl_check_user_ram_access_exit(t_mem, sizeof(struct mem_heap), 1, _this->blong_user);
if (t_mem->used==0 || t_mem->size < MEM_HEAP_STRUCT_SIZE || t_mem->size < size || size< MEM_HEAP_STRUCT_SIZE) {
sche_unlock();
return NULL;
}
r_mem = (struct mem_heap*)((ptr_t)t_mem + size);
knl_check_user_ram_access_exit(r_mem, sizeof(struct mem_heap), 1, _this->blong_user);
r_mem->used = 1;
r_mem->size = t_mem->size - size;
r_mem->next = t_mem->next;
@@ -116,7 +123,7 @@ again_alloc:
align_ptr = (void*)ALIGN((ptr_t)mem, align);
if (align_ptr == mem) {
if (alloc_size - size >= align && align > MEM_HEAP_STRUCT_SIZE) {
void* split_addr = mem_split(mem, alloc_size- (size- MEM_HEAP_STRUCT_SIZE));
void* split_addr = mem_split(_this, mem, alloc_size- (size- MEM_HEAP_STRUCT_SIZE));
if (!split_addr) {
mem_free(_this, split_addr);
}
@@ -125,7 +132,7 @@ again_alloc:
return mem;
}
else {
void* split_addr = mem_split(mem, (ptr_t)align_ptr - (ptr_t)mem);
void* split_addr = mem_split(_this, mem, (ptr_t)align_ptr - (ptr_t)mem);
if (split_addr == NULL) {
*(((uint32_t*)(align_ptr)) - 1) = (uint32_t)mem;
return align_ptr;
@@ -148,12 +155,16 @@ again_alloc:
void mem_free_align(mem_t *_this, void* f_mem) {
struct mem_heap* mem;
void* real_mem;
sche_lock();
for (mem = _this->heap_start; mem != _this->heap_end; mem = mem->next) {
knl_check_user_ram_access_exit(mem, sizeof(struct mem_heap), 1, _this->blong_user);
MKRTOS_ASSERT(mem->magic == MAGIC_NUM);
if ((ptr_t)mem == (ptr_t)f_mem- MEM_HEAP_STRUCT_SIZE) {
break;
}
}
sche_unlock();
if (mem == _this->heap_end) {
real_mem = (void*)(*(((uint32_t*)(f_mem)) - 1));
mem_free(_this, real_mem);
@@ -177,11 +188,13 @@ void* mem_alloc(mem_t *_this, uint32_t size) {
size = ALIGN(size, 4);
sche_lock();
for (mem = _this->l_heap; mem != _this->heap_end; mem = mem->next) {
knl_check_user_ram_access_exit(mem, sizeof(struct mem_heap), 1, _this->blong_user);
MKRTOS_ASSERT(mem->magic == MAGIC_NUM);
if (mem->used == 0 && mem->size > size) {
if (mem->size - size > MEM_HEAP_STRUCT_SIZE) {
struct mem_heap* mem_temp = NULL;
mem_temp = (struct mem_heap*)((ptr_t)mem + MEM_HEAP_STRUCT_SIZE + size);
knl_check_user_ram_access_exit(mem_temp, sizeof(struct mem_heap), 1, _this->blong_user);
mem_temp->next = mem->next;
mem_temp->prev = mem;
mem_temp->used = 0;
@@ -210,7 +223,6 @@ int mem_heap_add(mem_t *_this, void* mem, uint32_t size) {
if (size < (MEM_HEAP_STRUCT_SIZE << 1)) {
return -1;
}
mem = (void*)(ALIGN((ptr_t)mem, 4));
size -= 4;
@@ -256,6 +268,7 @@ size_t mem_get_free_size(mem_t *_this)
sche_lock();
for (mem = _this->heap_start; mem != _this->heap_end; mem = mem->next) {
knl_check_user_ram_access_exit(mem, sizeof(struct mem_heap), 1, _this->blong_user);
MKRTOS_ASSERT(mem->magic == MAGIC_NUM);
if (!mem->used) {
size += mem->size;
@@ -278,7 +291,9 @@ struct mem_heap* mem_get_free(mem_t *_this, struct mem_heap* next,
}
sche_lock();
knl_check_user_ram_access_exit(mem, sizeof(struct mem_heap), 1, _this->blong_user);
for (; mem != _this->heap_end; mem = mem->next) {
knl_check_user_ram_access_exit(mem, sizeof(struct mem_heap), 1, _this->blong_user);
MKRTOS_ASSERT(mem->magic == MAGIC_NUM);
if (hope_size > 0 && !mem->used && mem->size >= hope_size) {
*ret_addr = (ptr_t)mem + MEM_HEAP_STRUCT_SIZE;
@@ -303,6 +318,7 @@ void mem_trace(mem_t *_this) {
kprint("end heap:0x%x.\n",_this->heap_end);
for (mem = _this->heap_start; mem != _this->heap_end; mem = mem->next) {
knl_check_user_ram_access_exit(mem, sizeof(struct mem_heap), 1, _this->blong_user);
kprint("%d [0x%x-] %dB\n",mem->used,mem,mem->size);
}
}

40
mkrtos_real/knl/sched.c
View File

@@ -125,7 +125,10 @@ void sche_lock(void) {
* 调度器解锁
*/
void sche_unlock(void) {
atomic_test_dec_nq(&(sys_tasks_info.sche_lock));
atomic_dec(&(sys_tasks_info.sche_lock));
// if (atomic_read(&(sys_tasks_info.sche_lock)) == 0 && sys_tasks_info.is_run) {
// task_sche();
// }
}
/**
* 获取调度器的锁计数
@@ -145,7 +148,7 @@ void task_sche(void) {
return;
}
//监测是否可以调度
if (atomic_test(&(sys_tasks_info.sche_lock), FALSE)) {
if (!atomic_test(&(sys_tasks_info.sche_lock), 0)) {
return;
}
t = dis_cpu_intr();
@@ -290,6 +293,7 @@ void del_task_all(struct task *del)
restore_cpu_intr(t);
task_update_cur();
}
/**
* @brief 通过优先级添加任务，如果这个优先级不存在，则创建该优先级的任务节点
* @param pSysTasks 任务管理对象
@@ -562,13 +566,22 @@ int32_t sys_nice(int32_t increment) {
return 0;
}
// /**
// * 结束时系统将会调用这函数
// * 非内核线程时，这个函数属于用户态
// * 内核线程时，这个函数删除线程
// */
// void task_end(void) {
// sys_exit(0);
// task_sche();
// }
/**
* 结束时系统将会调用这函数
* 非内核线程时，这个函数属于用户态
* 内核线程时，这个函数删除线程
*/
void task_end(void) {
sys_exit(0);
do_exit(0);
}
/**
* @brief 创建任务
@@ -772,24 +785,37 @@ int sys_setpriority(int which, int who, int prio) {
end: restore_cpu_intr(t);
return ret;
}
static void prio_list_del(struct sys_task_base_links *del_prio_list)
{
uint32_t t = dis_cpu_intr();
if (del_prio_list->task_count == 0) {
slist_del(&del_prio_list->_next);
free(del_prio_list);
}
restore_cpu_intr(t);
}
pid_t shutdown_task(struct task *ls) {
int32_t res_pid;
struct sys_task_base_links *tmp;
tmp = ls->parent;
ls->parent->task_count--;
del_task_prio(ls);
del_task_all(ls);
prio_list_del(tmp);
res_pid = ls->pid;
free(ls);
//knl_mem_trace();
// kprint("\nfree size:%dB\n", free_size());
return res_pid;
}
void thread_idle(void *arg) {
int last_r_cn = 0;
while (1) {
//TODO:
if (sys_tasks_info.wait_r) {
if (!atomic_test_dec_nq(&sys_tasks_info.wait_r)) {
struct task *all;
sys_tasks_info.wait_r--;
sche_lock();
again:
slist_foreach(all, &sys_tasks_info.all_tk_list, all_node) {
@@ -826,7 +852,7 @@ void init_sche(void) {
slist_init(&sys_tasks_info.all_tk_list);
slist_init(&sys_tasks_info.prio_head_task_list);
/*OS是否调度初始化*/
atomic_set(&sys_tasks_info.sche_lock, 1);
atomic_set(&sys_tasks_info.sche_lock, 0);
/*进程pid分配变量*/
atomic_set(&sys_tasks_info.pid_temp, 1);
sys_tasks_info.current_max_task_node = NULL;

1
mkrtos_real/knl/syscall.c
View File

@@ -42,7 +42,6 @@ int syscall_none(void){
return -ENOSYS;
}
static const int syscall_func_number=sizeof(sys_call_table)/sizeof(sys_call_func);
void* get_syscall_handler(void* sp,int32_t call_num){

22
mkrtos_real/main.c
View File

@@ -19,14 +19,20 @@
//4.应用程序直接加载bin文件执行
void thread_main(void *arg0, void *arg1) {
int ret;
sys_tasks_info.is_run = TRUE;
mkrtos_test();
// #if 0
setup();
const char * const argv[] = {
"/bin/zh"
,0
};
sys_execve("/bin/zh",argv);
// #endif
kprint("done!\n");
while(1);
while(1) {
sleep_ms(1000);
}
}
// static void delay(void)
// {
@@ -36,9 +42,9 @@ void thread_main(void *arg0, void *arg1) {
// }
#include <stm32f2xx.h>
int main(void) {
//delay();
extern int32_t bk_flash_init(void);
extern int32_t sp_mkfs(dev_t dev_no, int32_t inode_count);
static struct task_create_par tcp;
int32_t pid;
extern int32_t bk_flash_init(void);
__enable_irq();
// //TODO:增加栈8字节对齐
((uint8_t *)(0xE000E008))[0] |= 0x6;
@@ -47,14 +53,6 @@ int main(void) {
//初始化默认的磁盘设备
root_dev_no = bk_flash_init();
// //在这里格式化文件系统
// if (sp_mkfs(root_dev_no, 30) < 0) {
// kfatal("根文件系统创建失败！\r\n");
// }
static struct task_create_par tcp;
int32_t pid;
init_sche();
tcp.task_fun = thread_main;

6
mkrtos_real/stm32f205rft6_link.lds
View File

@@ -49,7 +49,11 @@ SECTIONS
_mkrtos_init_start = .;
KEEP (*(SORT(.mkrtos.init.*)))
_mkrtos_init_end = .;
. = ALIGN(4);
_mkrtos_init_test_start = .;
KEEP (*(SORT(.mkrtos.test.*)))
_mkrtos_init_test_end = .;
. = ALIGN(4);
_etext = .; /* define a global symbols at end of code */

23
mkrtos_real/test/test_fs.c Normal file
View File

@@ -0,0 +1,23 @@
#include <arch/atomic.h>
#include <mkrtos/sched.h>
#include "config.h"
#include "knl_service.h"
#include <mm.h>
static int test_fs(void)
{
// int sys_mknod(const char * filename, int mode, dev_t dev);
// int sys_mkdir(const char * pathname, int mode);
// int32_t sys_open(const char* path,int32_t flags,int32_t mode);
// int sys_write (int fd,uint8_t *buf,uint32_t len);
// int sys_read (int fd,uint8_t *buf,uint32_t len);
// void sys_close(int fp);
// int sys_readdir(unsigned int fd, struct dirent * dirent, uint32_t count);
return 0;
}
INIT_TEST_REG(test_fs, INIT_TEST_LVL);

2
mkrtos_real/test/test_i_startup.c
View File

@@ -48,4 +48,4 @@ int test_mem(void)
return 0;
}
INIT_REG(test_mem, INIT_TEST_LVL);
INIT_TEST_REG(test_mem, INIT_TEST_LVL);

2
mkrtos_real/test/test_sched.c
View File

@@ -24,4 +24,4 @@ static int test_sched(void)
return 0;
}
INIT_REG(test_sched, INIT_TEST_LVL);
INIT_TEST_REG(test_sched, INIT_TEST_LVL);

79
mkrtos_real/test/test_thread.c Normal file
View File

@@ -0,0 +1,79 @@
#include <arch/atomic.h>
#include <mkrtos/sched.h>
#include "config.h"
#include "knl_service.h"
#include <mm.h>
static void test_thread_entry(int arg0, int arg1)
{
struct task *cur_task;
cur_task = get_current_task();
MKRTOS_ASSERT(arg0 == 1);
MKRTOS_ASSERT(arg1 == 2);
//kprint("pid:%d\n", cur_task->pid);
}
static void test_thread_prio(int arg0, int arg1)
{
struct task *cur_task;
cur_task = get_current_task();
MKRTOS_ASSERT(arg0 == 1);
MKRTOS_ASSERT(arg1 == 2);
sleep_ms(50);
kprint("pid:%d prio:%d\n", cur_task->pid, cur_task->prio);
}
static int test_thread(void)
{
pid_t pid;
static struct task_create_par tcp;
kprint("=======start sched mem\n");
for (int i = 0; i < 100; i++) {
tcp.task_fun = test_thread_entry;
tcp.arg0 = (void*) 1;
tcp.arg1 = 2;
tcp.prio = 6;
tcp.exec_id = -1;
tcp.user_stack_size = 0;
tcp.kernel_stack_size = 256;
tcp.task_name = "main";
pid = task_create(&tcp, TRUE);
if (pid < 0) {
sleep_ms(50);
continue;
}
}
while(atomic_read(&sys_tasks_info.wait_r)!=0) {
sleep_ms(500);
}
sleep_ms(500);
sche_lock();
for (int i = 1; i <= 3; i++) {
tcp.task_fun = test_thread_prio;
tcp.arg0 = (void*) 1;
tcp.arg1 = 2;
tcp.prio = i;
tcp.exec_id = -1;
tcp.user_stack_size = 0;
tcp.kernel_stack_size = 256;
tcp.task_name = "main";
pid = task_create(&tcp, TRUE);
if (pid < 0) {
kprint("=======prio test fail.\n");
break;
}
}
sche_unlock();
while(atomic_read(&sys_tasks_info.wait_r)!=0) {
sleep_ms(500);
}
sleep_ms(1000);
knl_mem_trace();
kprint("=======end sched mem\n");
return 0;
}
INIT_TEST_REG(test_thread, INIT_TEST_LVL);

2
setting.cmake
View File

@@ -1,4 +1,4 @@
set(CMAKE_TOOLCHAIN_PATH "${CMAKE_SOURCE_DIR}/toolchains/gcc-arm-none-eabi-5_4-2016q3/bin/" CACHE STRING " " FORCE)
set(CMAKE_TOOLCHAIN_PATH "${CMAKE_SOURCE_DIR}/toolchains/gcc-arm-none-eabi-4_9-2014q4/bin/" CACHE STRING " " FORCE)
set(CROSS_COMPILE ${CMAKE_TOOLCHAIN_PATH}arm-none-eabi- CACHE PATH "" FORCE)
set(CMAKE_INSTALL_PATH "${CMAKE_BINARY_DIR}deploy" CACHE PATH "" FORCE)

4
stm32f205rft6_build.sh
View File

@@ -2,8 +2,8 @@
export MYDIR=$PWD
export APP=mkrtos
export CMAKE_SIZE=$MYDIR/toolchains/gcc-arm-none-eabi-5_4-2016q3/bin/arm-none-eabi-size
export CMAKE_OBJCOPY=$MYDIR/toolchains/gcc-arm-none-eabi-5_4-2016q3/bin/arm-none-eabi-objcopy
export CMAKE_SIZE=$MYDIR/toolchains/gcc-arm-none-eabi-4_9-2014q4/bin/arm-none-eabi-size
export CMAKE_OBJCOPY=$MYDIR/toolchains/gcc-arm-none-eabi-4_9-2014q4/bin/arm-none-eabi-objcopy
set -e
sudo rm -f build/bin/*