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

尝试启动shell

Browse Source
This commit is contained in:
zhangzheng
2024-04-08 20:04:34 +08:00
parent 1a2c180fa2
commit c61745f096
21 changed files with 335 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.vscode/launch.json vendored
View File

@@ -46,9 +46,9 @@
"environment": [],
"externalConsole": false,
// "miDebuggerPath": "/opt/homebrew/bin/arm-none-eabi-gdb",
"miDebuggerPath": "/home/zhangzheng/gcc-arm-10.3-2021.07-aarch64-aarch64-none-elf/bin/aarch64-none-elf-gdb",
"miDebuggerPath": "/home/mkrtos-smart/toolchains/gcc-arm-10.3-2021.07-x86_64-aarch64-none-elf/bin/aarch64-none-elf-gdb",
// "miDebuggerPath": "/home/zhangzheng/gcc-arm-none-eabi-5_4-2016q3/bin/arm-none-eabi-gdb",
"miDebuggerServerAddress": "127.0.0.1:3333",
"miDebuggerServerAddress": "127.0.0.1:33333",
"MIMode": "gdb",
"setupCommands": [
{

6
.vscode/settings.json vendored
View File

@@ -1,5 +1,6 @@
{
"files.associations": {
".*": ".cc",
"types.h": "c",
"string.h": "c",
"cpio.h": "c",
@@ -58,7 +59,10 @@
"thread_knl.h": "c",
"shell.h": "c",
"shell_secure_user.h": "c",
"u_log.h": "c"
"u_log.h": "c",
"elf.h": "c",
"u_vmam.h": "c",
"u_arch_hard.h": "c"
},
"cortex-debug.showRTOS": false,
"cortex-debug.variableUseNaturalFormat": false,

2
mkrtos_configs/aarch64_qemu_defconfig
View File

@@ -6,7 +6,7 @@ CONFIG_KNL_INFO=y
CONFIG_KNL_TEXT_ADDR=0x1000
CONFIG_KNL_TEXT_SIZE=0x100000
CONFIG_KNL_DATA_ADDR=0x40000000
CONFIG_KNL_DATA_SIZE=0x7c000000
CONFIG_KNL_DATA_SIZE=0x1E000000
CONFIG_KNL_OFFSET=0x1000000
CONFIG_INIT_TASK_OFFSET=0x10000
CONFIG_BOOTFS_OFFSET=0x02000000

4
mkrtos_knl/arch/aarch64/mmu.c
View File

@@ -184,6 +184,10 @@ static SECTION(TEXT_BOOT_SECTION) void boot_init_pageing(page_entry_t *kpdir, bo
int i_ffs = ffs(CONFIG_KNL_DATA_SIZE) + (is_power_of_2(CONFIG_KNL_DATA_SIZE) ? 0 : 1);
int i_cn = 0;
if (i_ffs<30) {
i_ffs = 30;
}
// 进行1比1映射
do
{

2
mkrtos_knl/inc/knl/thread.h
View File

@@ -123,7 +123,7 @@ typedef struct thread
umword_t magic; //!< maigc
} thread_t;
static inline void thread_set_msg_bug(thread_t *th, void *msg, void *umsg)
static inline void thread_set_msg_buf(thread_t *th, void *msg, void *umsg)
{
th->msg.msg = msg;
th->msg.umsg = umsg;

2
mkrtos_knl/inc/knl/util.h
View File

@@ -26,6 +26,8 @@
#define SECTION(section) __attribute__((__section__(section)))
#define __ALIGN__(size) __attribute__((aligned(size)))
#define __WEAK__ __attribute__((weak))
#define container_of(ptr, type, member) \
((type *)(((umword_t)(ptr)) - ((umword_t)(&(((type *)0)->member)))))

15
mkrtos_knl/inc/knl/vma.h
View File

@@ -124,7 +124,20 @@ int task_vma_init(task_vma_t *vma);
*/
int task_vma_alloc(task_vma_t *task_vma, vma_addr_t vaddr, size_t size,
paddr_t paddr, vaddr_t *ret_vaddr);
/**
* @brief 将一个task的内存转移给另一个task
* 1.查找源中是否存在
* 2.查找目的中是否存在
* 3.虚拟地址节点从源中删除，插入到目的
* 4.物理地址从源中解除映射，并从树中删除，插入到目的，并映射到目的端。
* @param src_task_vma
* @param dst_task_vma
* @param src_addr
* @param size
* @return int
*/
int task_vma_grant(task_vma_t *src_task_vma, task_vma_t *dst_task_vma,
vaddr_t src_addr, vaddr_t dst_addr, size_t size);
/**
* @brief 释放申请的虚拟内存，并释放已经申请的物理内存
* 1.从分配树中找到需要的节点

90
mkrtos_knl/knl/mm/vma.c
View File

@@ -461,6 +461,59 @@ static int vma_idl_tree_eq_cmp_handler(const void *key, const void *data)
return 1;
}
}
typedef struct vma_idl_tree_iter_grant_params
{
vaddr_t addr;
vaddr_t dst_addr;
size_t size;
mln_rbtree_t *r_src_tree;
mln_rbtree_t *r_dst_tree;
task_vma_t *src_mm_vma;
task_vma_t *dst_mm_vma;
size_t grant_size;
} vma_idl_tree_iter_grant_params_t;
/**
* @brief 迭代转移
*
* @param node
* @param udata
* @return int
*/
static int rbtree_iterate_tree_grant(mln_rbtree_node_t *node, void *udata)
{
vma_idl_tree_iter_grant_params_t *param = udata;
vma_t *node_data = mln_rbtree_node_data_get(node);
if (vma_addr_get_addr(node_data->vaddr) >= param->addr &&
vma_addr_get_addr(node_data->vaddr) + node_data->size <= param->addr + param->size)
{
mm_space_t *src_mm_space = container_of(param->src_mm_vma, mm_space_t, mem_vma);
mm_space_t *dst_mm_space = container_of(param->dst_mm_vma, mm_space_t, mem_vma);
// 从红黑树中删除
mln_rbtree_delete(param->r_src_tree, node);
vaddr_t dst_addr;
dst_addr = vma_addr_get_addr(node_data->vaddr) - param->addr + param->dst_addr;
// 解除映射
unmap_mm(mm_space_get_pdir(src_mm_space),
vma_addr_get_addr(node_data->vaddr), PAGE_SHIFT, 1);
int ret = map_mm(mm_space_get_pdir(src_mm_space), dst_addr,
(addr_t)vma_node_get_paddr(node_data), PAGE_SHIFT, 1,
vpage_attrs_to_page_attrs(vma_addr_get_prot(node_data->vaddr)));
if (ret >= 0) {
param->grant_size += PAGE_SIZE;
}
vma_addr_set_addr(&node_data->vaddr, dst_addr);
mln_rbtree_insert(param->r_dst_tree, node);
}
return 0;
}
/**
* @brief 将一个task的内存转移给另一个task
* 1.查找源中是否存在
@@ -473,7 +526,7 @@ static int vma_idl_tree_eq_cmp_handler(const void *key, const void *data)
* @param size
* @return int
*/
int task_vam_grant(task_vma_t *src_task_vma, task_vma_t *dst_task_vma, vaddr_t src_addr, size_t size)
int task_vma_grant(task_vma_t *src_task_vma, task_vma_t *dst_task_vma, vaddr_t src_addr, vaddr_t dst_addr, size_t size)
{
assert(src_task_vma);
assert(dst_task_vma);
@@ -491,7 +544,6 @@ int task_vam_grant(task_vma_t *src_task_vma, task_vma_t *dst_task_vma, vaddr_t s
{
return lock_status;
}
/*TODO:*/
mln_rbtree_node_t *src_node;
mln_rbtree_node_t *dst_node;
@@ -519,22 +571,33 @@ int task_vam_grant(task_vma_t *src_task_vma, task_vma_t *dst_task_vma, vaddr_t s
&dst_task_vma->idle_tree,
&(vma_idl_tree_insert_params_t){
.size = size,
.addr = src_addr,
.addr = dst_addr,
}); //!< 查找是否存在
if (mln_rbtree_null(dst_node, &dst_task_vma->idle_tree))
{
ret = -ENOENT;
goto end;
}
if (vma_node_get_used(mln_rbtree_node_data_get(dst_node)))
if (!mln_rbtree_null(dst_node, &dst_task_vma->idle_tree))
{
ret = -EEXIST;
goto end;
}
ret = 0;
/*转移映射*/
mln_rbtree_delete(&src_task_vma->idle_tree,src_node);
vma_idl_tree_iter_grant_params_t params = {
.addr = src_addr,
.dst_addr = dst_addr,
.size = size,
.r_src_tree = &src_task_vma->alloc_tree,
.r_dst_tree = &dst_task_vma->alloc_tree,
.src_mm_vma = src_task_vma,
.dst_mm_vma = dst_task_vma,
};
//从源task的分配树中转移到目的task的分配树中。
mln_rbtree_iterate(&src_task_vma->alloc_tree, rbtree_iterate_tree_grant, &params);
mln_rbtree_insert(&src_task_vma->idle_tree,src_node);
ret = params.grant_size;
end:
task_vma_unlock_two(src_task_vma, dst_task_vma);
task_vma_unlock_two(src_task_vma, dst_task_vma, lock_status0, lock_status1);
return ret;
}
@@ -804,12 +867,15 @@ int task_vma_page_fault(task_vma_t *task_vma, vaddr_t addr)
// 4.进行映射
ret = map_mm(mm_space_get_pdir(&task->mm_space), addr,
(addr_t)mem, PAGE_SHIFT, 1,
vpage_attrs_to_page_attrs(vma_addr_get_prot(node_data->vaddr))); /*TODO:设置权限*/
vpage_attrs_to_page_attrs(vma_addr_get_prot(node_data->vaddr)));
if (ret < 0)
{
vma_node_free(&task_vma->alloc_tree, alloc_node);
ret = -ENOMEM;
goto end;
}
task_vma->alloc_tree.cmp = vma_idl_tree_insert_cmp_handler;
mln_rbtree_insert(&task_vma->alloc_tree, alloc_node);
ret = 0;
end:
task_vma_unlock(task_vma, lock_status);

20
mkrtos_knl/knl/mm/vma_obj.c
View File

@@ -31,6 +31,7 @@ enum
{
VMA_ALLOC,
VMA_FREE,
VMA_GRANT,
};
static void vma_obj_syscall(kobject_t *kobj, syscall_prot_t sys_p, msg_tag_t in_tag, entry_frame_t *f)
@@ -66,7 +67,24 @@ static void vma_obj_syscall(kobject_t *kobj, syscall_prot_t sys_p, msg_tag_t in_
{
int ret;
task_vma_free(&tk->mm_space.mem_vma, f->regs[0], f->regs[1]);
ret = task_vma_free(&tk->mm_space.mem_vma, f->regs[0], f->regs[1]);
f->regs[0] = msg_tag_init4(0, 0, 0, ret).raw;
}
break;
case VMA_GRANT:
{
int ret;
kobject_t *kobj;
kobj = obj_space_lookup_kobj_cmp_type(&tk->obj_space, f->regs[0], TASK_TYPE);
if (kobj==NULL) {
f->regs[0] = msg_tag_init4(0, 0, 0, -ENOENT).raw;
break;
}
ret = task_vma_grant(&tk->mm_space.mem_vma, &((task_t *)kobj)->mm_space.mem_vma,
f->regs[1], f->regs[2], f->regs[3]);
f->regs[0] = msg_tag_init4(0, 0, 0, ret).raw;
}
break;

2
mkrtos_knl/knl/thread.c
View File

@@ -780,7 +780,7 @@ static void thread_syscall(kobject_t *kobj, syscall_prot_t sys_p, msg_tag_t in_t
{
if (is_rw_access(thread_get_bind_task(tag_th), (void *)(f->regs[1]), THREAD_MSG_BUG_LEN, FALSE))
{
thread_set_msg_bug(tag_th, NULL /*TODO:*/, (void *)(f->regs[1]));
thread_set_msg_buf(tag_th, NULL /*TODO:*/, (void *)(f->regs[1]));
tag = msg_tag_init4(0, 0, 0, 0);
}
else

6
mkrtos_knl/knl/thread_knl.c
View File

@@ -101,7 +101,7 @@ static void knl_init_1(void)
task_knl_init(&knl_task);
thread_knl_pf_set(knl_thread, knl_main);
thread_bind(knl_thread, &knl_task.kobj);
thread_set_msg_bug(knl_thread, knl_msg_buf, knl_msg_buf);
thread_set_msg_buf(knl_thread, knl_msg_buf, knl_msg_buf);
thread_ready(knl_thread, FALSE);
slist_init(&del_task_head);
@@ -146,7 +146,7 @@ static void knl_init_2(void)
assert(task_vma_alloc(&init_task->mm_space.mem_vma,
vma_addr_create(VPAGE_PROT_RO, VMA_ADDR_RESV, CONFIG_BOOT_FS_VADDR),
cpio_get_size(cpio_images), (paddr_t)cpio_images, 0) >= 0);
thread_set_msg_bug(init_thread, (void *)init_msg_buf, (void *)CONFIG_MSG_BUF_VADDR);
thread_set_msg_buf(init_thread, (void *)init_msg_buf, (void *)CONFIG_MSG_BUF_VADDR);
thread_user_pf_set(init_thread, (void *)(entry), (void *)0xdeaddead,
NULL, 0);
#else
@@ -156,7 +156,7 @@ static void knl_init_2(void)
void *sp_addr = (char *)init_task->mm_space.mm_block + app->i.stack_offset - app->i.data_offset;
void *sp_addr_top = (char *)sp_addr + app->i.stack_size;
thread_set_msg_bug(init_thread, (char *)(init_task->mm_space.mm_block) + app->i.ram_size, (char *)(init_task->mm_space.mm_block) + app->i.ram_size);
thread_set_msg_buf(init_thread, (char *)(init_task->mm_space.mm_block) + app->i.ram_size, (char *)(init_task->mm_space.mm_block) + app->i.ram_size);
thread_user_pf_set(init_thread, (void *)(CONFIG_KNL_TEXT_ADDR + CONFIG_INIT_TASK_OFFSET), (void *)((umword_t)sp_addr_top - 8),
init_task->mm_space.mm_block, 0);
#endif

8
mkrtos_script/build_qemu_aarch64.sh
View File

@@ -1,9 +1,9 @@
#!/bin/bash
export TOOLCHAIN=/home/zhangzheng/gcc-arm-10.3-2021.07-aarch64-aarch64-none-elf/bin/
export TOOLCHAIN_LIB=/home/zhangzheng/gcc-arm-10.3-2021.07-aarch64-aarch64-none-elf/lib/gcc/aarch64-none-elf/10.3.1
# export TOOLCHAIN=/home/mkrtos-smart/toolchains/gcc-arm-10.3-2021.07-x86_64-aarch64-none-elf/bin/
# export TOOLCHAIN_LIB=/home/mkrtos-smart/toolchains/gcc-arm-10.3-2021.07-x86_64-aarch64-none-elf/lib/gcc/aarch64-none-elf/10.3.1
# export TOOLCHAIN=/home/zhangzheng/gcc-arm-10.3-2021.07-aarch64-aarch64-none-elf/bin/
# export TOOLCHAIN_LIB=/home/zhangzheng/gcc-arm-10.3-2021.07-aarch64-aarch64-none-elf/lib/gcc/aarch64-none-elf/10.3.1
export TOOLCHAIN=/home/mkrtos-smart/toolchains/gcc-arm-10.3-2021.07-x86_64-aarch64-none-elf/bin/
export TOOLCHAIN_LIB=/home/mkrtos-smart/toolchains/gcc-arm-10.3-2021.07-x86_64-aarch64-none-elf/lib/gcc/aarch64-none-elf/10.3.1
export BOARD=aarch64_qemu
export CROSS_COMPILE_NAME=aarch64-none-elf-

2
mkrtos_script/debug_aarch64_qemu.sh
View File

@@ -10,7 +10,7 @@ qemu-system-aarch64 \
-machine virt,virtualization=on,gic-version=2,highmem=off,secure=off\
-cpu cortex-a53 \
-nographic \
-m size=2048 \
-m size=512 \
-smp 4\
-kernel $PWD/build/output/bootstrap.elf \
-S -gdb tcp::$1

2
mkrtos_script/run_aarch64_qemu.sh
View File

@@ -5,6 +5,6 @@ qemu-system-aarch64 \
-machine virt,virtualization=on,gic-version=2,highmem=off,secure=off\
-cpu cortex-a53 \
-nographic \
-m size=2048 \
-m size=512 \
-smp 4\
-kernel $PWD/build/output/bootstrap.elf

3
mkrtos_user/lib/sys/inc/u_arch.h
View File

@@ -3,7 +3,8 @@
#include "u_arch_hard.h"
#define MK_PAGE_SIZE (1UL << CONFIG_PAGE_SHIFT)
#define PAGE_SIZE (1UL << CONFIG_PAGE_SHIFT)
#define MK_PAGE_SIZE (PAGE_SIZE)
#define WORD_BYTES (sizeof(void *))
#define WORD_BITS (WORD_BYTES * 8)

13
mkrtos_user/lib/sys/inc/u_vmam.h
View File

@@ -4,9 +4,14 @@
enum vpage_prot_attrs
{
VPAGE_PROT_RO = 1, //!< 只读
VPAGE_PROT_RW = VPAGE_PROT_RO | 0x2, //!< 读写
VPAGE_PROT_RWX = (VPAGE_PROT_RO | VPAGE_PROT_RW | 0x4), //!< 读写执行
VPAGE_PROT_RO = 1, //!< 只读
VPAGE_PROT_WO = 0x2,
VPAGE_PROT_RW = VPAGE_PROT_RO | VPAGE_PROT_WO, //!< 读写
VPAGE_PROT_X = 0x4,
VPAGE_PROT_RWX = (VPAGE_PROT_RO | VPAGE_PROT_RW | VPAGE_PROT_X), //!< 读写执行
VPAGE_PROT_UNCACHE = 0x10, //!< 不使用缓存
VPAGE_PROT_IN_KNL = 0x20, //!< 内核中使用
};
#define VMA_ADDR_RESV 0x1 //!< 保留内存
@@ -40,4 +45,6 @@ static inline vma_addr_t vma_addr_create(uint8_t prot, uint8_t flags, umword_t a
};
}
msg_tag_t u_vmam_alloc(obj_handler_t obj, vma_addr_t addr, size_t size, addr_t paddr, addr_t *vaddr);
msg_tag_t u_vmam_grant(obj_handler_t obj, obj_handler_t dst_task_obj,
addr_t src_addr, addr_t dst_addr, size_t size);
msg_tag_t u_vmam_free(obj_handler_t obj, addr_t addr, size_t size);

20
mkrtos_user/lib/sys/src/u_vmam.c
View File

@@ -7,6 +7,7 @@ enum
{
VMA_ALLOC,
VMA_FREE,
VMA_GRANT,
};
msg_tag_t u_vmam_alloc(obj_handler_t obj, vma_addr_t addr, size_t size, addr_t paddr, addr_t *vaddr)
@@ -32,6 +33,25 @@ msg_tag_t u_vmam_alloc(obj_handler_t obj, vma_addr_t addr, size_t size, addr_t p
return msg_tag_init(r0);
}
msg_tag_t u_vmam_grant(obj_handler_t obj, obj_handler_t dst_task_obj,
addr_t src_addr, addr_t dst_addr, size_t size)
{
register volatile umword_t r0 asm(ARCH_REG_0);
mk_syscall(syscall_prot_create4(VMA_GRANT, VMA_PROT, obj, FALSE).raw,
dst_task_obj,
src_addr,
dst_addr,
size,
0,
0);
asm __volatile__(""
:
:
: ARCH_REG_0);
return msg_tag_init(r0);
}
msg_tag_t u_vmam_free(obj_handler_t obj, addr_t addr, size_t size)
{

5
mkrtos_user/lib/sys_util/inc/u_elf64.h Normal file
View File

@@ -0,0 +1,5 @@
#pragma once
#include <u_types.h>
int elf_load(umword_t elf_data, size_t size, addr_t *entry_addr, obj_handler_t dst_task);

92
mkrtos_user/lib/sys_util/src/u_elf64.c Normal file
View File

@@ -0,0 +1,92 @@
#include <elf.h>
#include <u_types.h>
#include <stdio.h>
#include <u_vmam.h>
#include <u_prot.h>
#include <string.h>
#include <assert.h>
#include <stdio.h>
static int elf_check(Elf64_Ehdr *ehdr)
{
if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG) != 0)
{
return -1;
}
if (ehdr->e_type != ET_EXEC)
{
return -1;
}
/*TODO:check arch.*/
return 0;
}
int elf_load(umword_t elf_data, size_t size, addr_t *entry_addr, obj_handler_t dst_task)
{
int ret;
Elf64_Ehdr *elf_header;
assert(entry_addr);
elf_header = (Elf64_Ehdr *)elf_data;
ret = elf_check(elf_header);
if (ret != 0)
{
return ret;
}
// int size = elf_header->e_phentsize;
Elf64_Phdr *elf_phdr = (Elf64_Phdr *)(elf_header->e_phoff + elf_data);
size_t mem_size = 0;
addr_t st_addr = 0;
addr_t end_addr = 0;
*entry_addr = elf_header->e_entry;
for (int i = 0; i < elf_header->e_phnum; i++, elf_phdr++)
{
if (elf_phdr->p_type == PT_LOAD)
{
printf("u[elf] paddr:0x%x vaddr:0x%x memsize:%d filesize:%d ofst:%d align:0x%x\n",
elf_phdr->p_vaddr, elf_phdr->p_paddr, elf_phdr->p_memsz, elf_phdr->p_filesz,
elf_phdr->p_offset, elf_phdr->p_align);
if (i == 0)
{
st_addr = elf_phdr->p_vaddr;
}
end_addr = ALIGN(elf_phdr->p_vaddr + elf_phdr->p_memsz, elf_phdr->p_align);
}
}
mem_size = end_addr - st_addr;
void *mem;
msg_tag_t tag;
tag = u_vmam_alloc(VMA_PROT, vma_addr_create(VPAGE_PROT_RWX, 0, 0), mem_size, 0, (addr_t *)(&mem));
if (msg_tag_get_val(tag) < 0)
{
return msg_tag_get_val(tag);
}
memset(mem, 0, mem_size);
mword_t offset = 0;
elf_phdr = (Elf64_Phdr *)(elf_header->e_phoff + elf_data);
for (int i = 0; i < elf_header->e_phnum; i++, elf_phdr++)
{
if (elf_phdr->p_type == PT_LOAD)
{
memcpy((char *)mem + (elf_phdr->p_vaddr - st_addr),
(void *)(elf_data + elf_phdr->p_offset),
elf_phdr->p_filesz);
offset += ALIGN(elf_phdr->p_memsz, elf_phdr->p_align);
}
}
tag = u_vmam_grant(VMA_PROT, dst_task, (addr_t)mem, st_addr, mem_size);
if (msg_tag_get_val(tag) < 0)
{
u_vmam_free(VMA_PROT, (addr_t)mem, mem_size);
return msg_tag_get_val(tag);
}
return ret;
}

115
mkrtos_user/lib/sys_util/src/u_elf_loader.c
View File

@@ -11,6 +11,7 @@
#include "u_types.h"
#include "u_prot.h"
#include "u_app.h"
#include "u_arch.h"
#include "u_factory.h"
#include "u_mm.h"
#include "u_task.h"
@@ -26,6 +27,9 @@
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <u_elf64.h>
#include <u_vmam.h>
/**
* @brief 向栈中存放数据
*
@@ -49,11 +53,8 @@ static umword_t app_stack_push(umword_t *stack, umword_t val)
*/
static void *app_stack_push_umword(obj_handler_t task_obj, umword_t **stack, umword_t val)
{
ipc_msg_t *msg = thread_get_cur_ipc_msg();
(*stack)--;
msg->msg_buf[0] = val;
task_copy_data(task_obj, *stack, sizeof(umword_t));
*(*stack) = val;
return *stack;
}
@@ -66,17 +67,12 @@ static void *app_stack_push_umword(obj_handler_t task_obj, umword_t **stack, umw
*/
static void *app_stack_push_str(obj_handler_t task_obj, umword_t **stack, const char *str)
{
ipc_msg_t *msg = thread_get_cur_ipc_msg();
int len = strlen(str) + 1;
char *cp_data = (char *)msg->msg_buf;
len = MIN(len, ARRAY_SIZE(msg->msg_buf) * sizeof(umword_t));
*stack -= ALIGN(len, sizeof(void *)) / sizeof(void *);
memcpy(cp_data, str, len);
cp_data[len - 1] = 0;
task_copy_data(task_obj, *stack, len);
for (int i = 0; i < len; i++) {
((char*)(*stack))[i] = str[i];
}
return *stack;
}
@@ -91,20 +87,34 @@ static void *app_stack_push_str(obj_handler_t task_obj, umword_t **stack, const
*/
static void *app_stack_push_array(obj_handler_t task_obj, umword_t **stack, uint8_t *arr, size_t len)
{
ipc_msg_t *msg = thread_get_cur_ipc_msg();
char *cp_data = (char *)msg->msg_buf;
len = MIN(len, ARRAY_SIZE(msg->msg_buf) * sizeof(umword_t));
*stack -= ALIGN(len, sizeof(void *)) / sizeof(void *);
memcpy(cp_data, arr, len);
cp_data[len - 1] = 0;
task_copy_data(task_obj, *stack, len);
memcpy(*stack, arr, len);
return *stack;
}
static int thread_set_msg_buf(obj_handler_t hd_task, obj_handler_t hd_thread)
{
addr_t mem;
msg_tag_t tag;
tag = u_vmam_alloc(VMA_PROT, vma_addr_create(VPAGE_PROT_RW, 0, 0), PAGE_SIZE, 0, (addr_t *)(&mem));
if (msg_tag_get_val(tag) < 0)
{
return msg_tag_get_val(tag);
}
memset((void *)mem, 0, PAGE_SIZE);
tag = u_vmam_grant(VMA_PROT, hd_task, (addr_t)mem, CONFIG_MSG_BUF_VADDR, PAGE_SIZE);
if (msg_tag_get_val(tag) < 0)
{
return msg_tag_get_val(tag);
}
//设置msgbuff,TODO:内核需要获取到对应的物理地址
tag = thread_msg_buf_set(hd_thread, (void *)(CONFIG_MSG_BUF_VADDR));
if (msg_tag_get_val(tag) < 0)
{
return msg_tag_get_val(tag);
}
return 0;
}
/**
* @brief 加载并执行一个app
*
@@ -115,6 +125,7 @@ int app_load(const char *name, uenv_t *cur_env, pid_t *pid, char *argv[], int ar
{
msg_tag_t tag;
sys_info_t sys_info;
int ret;
tag = sys_read_info(SYS_PROT, &sys_info);
if (msg_tag_get_val(tag) < 0)
@@ -123,24 +134,18 @@ int app_load(const char *name, uenv_t *cur_env, pid_t *pid, char *argv[], int ar
}
int type;
umword_t addr;
int ret = cpio_find_file((umword_t)sys_info.bootfs_start_addr, (umword_t)(-1), name, NULL, &type, &addr);
umword_t size;
ret = cpio_find_file((umword_t)sys_info.bootfs_start_addr, (umword_t)(-1), name, &size, &type, &addr);
if (ret < 0 || (ret >= 0 && type == 1))
{
return -ENOENT;
}
app_info_t *app = app_info_get((void *)addr);
if (app == NULL)
{
printf("app format is error.\n");
return -1;
}
printf("%s addr is [0x%x]\n", name, app);
umword_t ram_base;
obj_handler_t hd_task = handler_alloc();
obj_handler_t hd_thread = handler_alloc();
addr_t entry_addr;
if (hd_task == HANDLER_INVALID)
{
@@ -156,16 +161,22 @@ int app_load(const char *name, uenv_t *cur_env, pid_t *pid, char *argv[], int ar
{
goto end_del_obj;
}
ret = elf_load(addr, size, &entry_addr, hd_task);
if (ret < 0) {
goto end_del_obj;
}
tag = factory_create_thread(FACTORY_PROT, vpage_create_raw3(KOBJ_ALL_RIGHTS, 0, hd_thread));
if (msg_tag_get_prot(tag) < 0)
{
goto end_del_obj;
}
tag = task_alloc_ram_base(hd_task, app->i.ram_size, &ram_base);
if (msg_tag_get_prot(tag) < 0)
{
goto end_del_obj;
}
// tag = task_alloc_ram_base(hd_task, app->i.ram_size, &ram_base);
// if (msg_tag_get_prot(tag) < 0)
// {
// goto end_del_obj;
// }
tag = task_map(hd_task, hd_task, TASK_PROT, 0);
if (msg_tag_get_prot(tag) < 0)
{
@@ -201,6 +212,11 @@ int app_load(const char *name, uenv_t *cur_env, pid_t *pid, char *argv[], int ar
{
goto end_del_obj;
}
tag = task_map(hd_task, VMA_PROT, VMA_PROT, KOBJ_DELETE_RIGHT);
if (msg_tag_get_prot(tag) < 0)
{
goto end_del_obj;
}
tag = task_map(hd_task, cur_env->ns_hd, cur_env->ns_hd, KOBJ_DELETE_RIGHT);
if (msg_tag_get_prot(tag) < 0)
{
@@ -211,10 +227,10 @@ int app_load(const char *name, uenv_t *cur_env, pid_t *pid, char *argv[], int ar
{
goto end_del_obj;
}
tag = thread_msg_buf_set(hd_thread, (void *)(ram_base + app->i.ram_size));
if (msg_tag_get_prot(tag) < 0)
{
ret = thread_set_msg_buf(hd_task, hd_thread);
if (ret < 0) {
goto end_del_obj;
}
tag = task_set_pid(hd_task, hd_task); //!< 设置进程的pid就是进程hd号码
if (msg_tag_get_prot(tag) < 0)
@@ -225,9 +241,17 @@ int app_load(const char *name, uenv_t *cur_env, pid_t *pid, char *argv[], int ar
{
*pid = hd_task;
}
void *sp_addr = (char *)ram_base + app->i.stack_offset - app->i.data_offset;
void *sp_addr_top = (char *)sp_addr + app->i.stack_size;
printf("stack:0x%x size:%d.\n", sp_addr, app->i.stack_size);
void *sp_addr;
void *sp_addr_top;
tag = u_vmam_alloc(VMA_PROT, vma_addr_create(VPAGE_PROT_RWX, 0, 0), CONFIG_PAGE_SHIFT * 8, 0, (addr_t *)(&sp_addr));
if (msg_tag_get_val(tag) < 0)
{
goto end_del_obj;
}
sp_addr_top = (char *)sp_addr_top + CONFIG_PAGE_SHIFT * 8;
printf("stack:0x%x size:%d.\n", sp_addr, CONFIG_PAGE_SHIFT * 8);
umword_t *usp_top = (umword_t *)((umword_t)((umword_t)sp_addr_top - 8) & ~0x7UL);
uenv_t uenv = {
.log_hd = cur_env->ns_hd,
@@ -275,8 +299,7 @@ int app_load(const char *name, uenv_t *cur_env, pid_t *pid, char *argv[], int ar
app_stack_push_umword(hd_task, &usp_top, arg_cn);
printf("pid:%d stack:%p\n", hd_task, usp_top);
tag = thread_exec_regs(hd_thread, (umword_t)addr, (umword_t)usp_top,
ram_base, 0);
tag = thread_exec_regs(hd_thread, (umword_t)addr, (umword_t)usp_top, 0, 0);
assert(msg_tag_get_prot(tag) >= 0);
/*启动线程运行*/
tag = thread_run(hd_thread, 2);

2
mkrtos_user/server/init/src/init.cfg
View File

@@ -4,5 +4,5 @@
# cpiofs
# dm9000_drv
# net
sh
sh.elf
# lcd_drv