yystopfceshi
/
xiuos
forked from yystopf/xiuos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use new sys tracer.

This commit is contained in:
TXuian 2024-05-09 09:39:07 +08:00
parent 3b011500f1
commit a19312df24
12 changed files with 138 additions and 728 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Ubiquitous/XiZi_AIoT/hardkernel/hardkernel_init.c
View File

@ -37,6 +37,7 @@ Modification:
#include "assert.h"
#include "pagetable.h"
#include "spinlock.h"
#define KERN_BOOT_DRIVER(n, bi, f) \
{ \

2
Ubiquitous/XiZi_AIoT/kernel_actracer/Makefile
View File

@ -1,4 +1,4 @@
SRC_DIR :=
SRC_FILES := actracer.c actracer_mem_chunk.c
SRC_FILES := actracer.c
include $(KERNEL_ROOT)/compiler.mk

536
Ubiquitous/XiZi_AIoT/kernel_actracer/actracer.c
View File

@ -29,267 +29,43 @@ Modification:
#include <stddef.h>
#include <string.h>
#include "trap_common.h"
#include "assert.h"
#include "multicores.h"
#include "spinlock.h"
#include "task.h"
#include "actracer.h"
#include "assert.h"
#ifndef min
#define min(a, b) ((a) < (b) ? (a) : (b))
#endif
static struct SysTracer sys_tracer;
static char root_name[TRACER_NODE_NAME_LEN] = "ROOT\0";
struct SysTracer sys_tracer;
char* tracer_space[TRACER_MEM_CHUNK_SIZE * NR_TRACER_MEM_CHUNKS];
struct TraceTag* const RequireRootTag()
void _tracer_init_node(TracerNode* node, char* name, tracemeta_ac_type type, void* p_resource)
{
static struct TraceTag root_trace_tag = { NULL };
return &root_trace_tag;
}
static inline int namecmp(const char* s, const char* t)
{
return strncmp(s, t, RESOURCE_NAME_SIZE);
}
/// @brief alloc a trace meta to trace resource
static struct TraceMeta* alloc_trace_meta()
{
int index = -1;
for (uint32_t idx = 0; idx < BITS_TRACEMETA_BITMAP; idx++) {
if (sys_tracer.trace_meta_bit_map[idx] == 0xFFFFFFFF) {
continue;
node->type = type;
node->parent = NULL;
if (name != NULL) {
char* p_name = (char*)slab_alloc(&sys_tracer.node_name_allocator);
strcpy(p_name, name);
p_name[TRACER_NODE_NAME_LEN - 1] = '\0';
node->name = p_name;
}
uint32_t position = __builtin_ffs(~sys_tracer.trace_meta_bit_map[idx]) - 1;
if (position != 31) {
// found a free bit
sys_tracer.trace_meta_bit_map[idx] |= (1 << (position));
index = idx * 32 + position;
break;
}
}
if (index == -1) {
panic("Tracer no enough TracerMeta.");
}
sys_tracer.trace_meta_poll[index].index = index;
return &sys_tracer.trace_meta_poll[index];
}
static bool dealloc_trace_meta(struct TraceMeta* meta)
{
int index = meta->index;
// clear bitmap
uint32_t outer_index = index / 32;
uint32_t inner_index = index % 32;
sys_tracer.trace_meta_bit_map[outer_index] &= (uint32_t)(~(1 << inner_index));
// clear meta
sys_tracer.trace_meta_poll[index].type = TRACER_INVALID;
if (index == -1) {
panic("Tracer no enough TracerMeta.");
}
sys_tracer.trace_meta_poll[index].index = index;
return &sys_tracer.trace_meta_poll[index];
}
static tracer_mem_chunk_idx_t trace_meta_map_mem_chunk(struct TraceMeta* const p_trace_meta, tracer_mem_chunk_idx_t mem_chunk_num)
{
tracer_mem_chunk_idx_t addr = 0;
/* direct mapping */
if (mem_chunk_num < TRACEMETA_NR_DIRECT) {
if ((addr = p_trace_meta->addr[mem_chunk_num]) == 0) {
p_trace_meta->addr[mem_chunk_num] = addr = tracer_mem_chunk_alloc();
}
return addr;
}
/* indirect mapping */
mem_chunk_num -= TRACEMETA_NR_DIRECT;
int indirect_mem_chunk_id = mem_chunk_num / NR_ADDR_PER_MEM_CHUNK;
if (indirect_mem_chunk_id < TRACEMETA_NR_INDIRECT) {
if ((addr = p_trace_meta->addr[TRACEMETA_NR_DIRECT + indirect_mem_chunk_id]) == 0) {
p_trace_meta->addr[TRACEMETA_NR_DIRECT + indirect_mem_chunk_id] = addr = tracer_mem_chunk_alloc();
}
mem_chunk_num -= indirect_mem_chunk_id * NR_ADDR_PER_MEM_CHUNK;
if (node->type == TRACER_OWNER) {
doubleListNodeInit(&node->children_guard);
} else {
panic("tracer inode, bmap out of range");
// no return
node->p_resource = p_resource;
}
// index mem_chunk
struct tracer_mem_chunk* tracer_mem_chunk = tracer_mem_chunk_read(addr);
tracer_mem_chunk_idx_t* indirect_list = (tracer_mem_chunk_idx_t*)tracer_mem_chunk->data;
if ((addr = indirect_list[mem_chunk_num]) == 0) {
indirect_list[mem_chunk_num] = addr = tracer_mem_chunk_alloc();
tracer_mem_chunk_write(tracer_mem_chunk);
}
tracer_mem_chunk_release(tracer_mem_chunk);
return addr;
doubleListNodeInit(&node->list_node);
}
/// @brief write trace info by trace meta
static int trace_write_info(struct TraceMeta* const p_trace_meta, char* src, uint32_t off, uint32_t n)
void sys_tracer_init()
{
if (p_trace_meta->type == TRACER_INVALID) {
return -1;
}
// set sys_tracer resource identity
_tracer_init_node(&sys_tracer.root_node, NULL, TRACER_OWNER, NULL);
sys_tracer.root_node.name = root_name;
sys_tracer.sys_tracer_tag.meta = &sys_tracer.root_node;
// fast path
if (off == 0 && n <= sizeof(uintptr_t)) {
p_trace_meta->reserved = *(uintptr_t*)src;
return n;
}
if (UNLIKELY(off > p_trace_meta->size || off + n > VFS_FILE_MAXSIZE * TRACER_MEM_CHUNK_SIZE || off + n < off)) {
return -1;
}
struct tracer_mem_chunk* tracer_mem_chunk;
uint32_t m;
for (uint32_t tot = 0; tot < n; tot += m, off += m, src += m) {
tracer_mem_chunk = tracer_mem_chunk_read(trace_meta_map_mem_chunk(p_trace_meta, off / TRACER_MEM_CHUNK_SIZE));
m = min(n - tot, TRACER_MEM_CHUNK_SIZE - off % TRACER_MEM_CHUNK_SIZE);
memmove(tracer_mem_chunk->data + off % TRACER_MEM_CHUNK_SIZE, src, m);
tracer_mem_chunk_write(tracer_mem_chunk);
tracer_mem_chunk_release(tracer_mem_chunk);
}
if (n > 0 && off > p_trace_meta->size) {
p_trace_meta->size = off;
}
return n;
// init memory allocator
slab_init(&sys_tracer.node_allocator, sizeof(TracerNode));
slab_init(&sys_tracer.node_name_allocator, sizeof(char[TRACER_NODE_NAME_LEN]));
}
/// @brief read trace info by trace meta
static int trace_read_info(struct TraceMeta* const p_trace_meta, char* dst, uint32_t off, uint32_t n)
{
if (p_trace_meta->type == TRACER_INVALID) {
return -1;
}
if (off == 0 && n <= sizeof(uintptr_t)) {
*(uintptr_t*)dst = p_trace_meta->reserved;
return n;
}
if (UNLIKELY(off > p_trace_meta->size || off + n < off)) {
return -1;
}
if (UNLIKELY(off + n > p_trace_meta->size)) {
n = p_trace_meta->size - off;
}
static struct tracer_mem_chunk* tracer_mem_chunk;
uint32_t m;
for (uint32_t tot = 0; tot < n; tot += m, off += m, dst += m) {
tracer_mem_chunk = tracer_mem_chunk_read(trace_meta_map_mem_chunk(p_trace_meta, off / TRACER_MEM_CHUNK_SIZE));
m = min(n - tot, TRACER_MEM_CHUNK_SIZE - off % TRACER_MEM_CHUNK_SIZE);
memmove(dst, tracer_mem_chunk->data + off % TRACER_MEM_CHUNK_SIZE, m);
tracer_mem_chunk_release(tracer_mem_chunk);
}
return n;
}
static struct TraceMeta* tracer_find_meta_onestep(struct TraceMeta* const p_owner, char* name, uint32_t* poff)
{
struct TraceResourceEntry resource_entry;
if (p_owner->type != TRACER_OWNER) {
ERROR("tracer_find_meta_onestep, not a dir, index: %d\n", p_owner->index);
return NULL;
}
for (uint32_t off = 0; off < p_owner->size; off += sizeof(resource_entry)) {
if (trace_read_info(p_owner, (char*)&resource_entry, off, sizeof(resource_entry)) != sizeof(resource_entry)) {
panic("tracer_find_meta_onestep: read trace owner's resources failed\n");
}
if (resource_entry.index == 0) {
continue;
}
if (namecmp(name, resource_entry.name) == 0) {
if (poff) {
*poff = off;
}
uint32_t vindex = resource_entry.index;
assert(vindex >= 0 && vindex < NR_MAX_TRACEMETA);
return &sys_tracer.trace_meta_poll[vindex];
}
}
return NULL;
}
// Write a new vdirectory entry (name, index) into the vdirectory dp.
static int tracer_append_meta(struct TraceMeta* p_owner, char* name, uint32_t index)
{
struct TraceResourceEntry resource_entry;
int offset = 0;
for (offset = 0; offset < p_owner->size; offset += sizeof(resource_entry)) {
if (trace_read_info(p_owner, (char*)&resource_entry, offset, sizeof(resource_entry)) != sizeof(resource_entry)) {
ERROR("tracer_append_meta failed, read owner's resources failed.\n");
return -1;
}
if (resource_entry.index == 0) {
break;
}
}
strncpy(resource_entry.name, name, RESOURCE_NAME_SIZE);
resource_entry.index = index;
if (trace_write_info(p_owner, (char*)&resource_entry, offset, sizeof(resource_entry)) != sizeof(resource_entry)) {
ERROR("tracer_append_meta failed, append resource to owner failed.\n");
return -1;
}
return 0;
}
static struct TraceMeta* tracer_new_meta(struct TraceMeta* p_owner, char* name, short type)
{
struct TraceMeta* p_trace_meta;
// check if owner entry exists
uint32_t offset;
if ((p_trace_meta = tracer_find_meta_onestep(p_owner, name, &offset)) != 0) {
LOG("create resource(trace meta) failed, %s is existed\n", name);
return NULL;
}
if ((p_trace_meta = alloc_trace_meta()) == 0) {
ERROR("create resource(trace meta) failed, cache is no free\n");
return NULL;
}
p_trace_meta->type = type;
p_trace_meta->size = 0;
// update parent directory
tracer_append_meta(p_owner, name, p_trace_meta->index);
// update "." and ".." for vfs inode
if (p_trace_meta->type == TRACER_OWNER) {
tracer_append_meta(p_trace_meta, ".", p_trace_meta->index);
tracer_append_meta(p_trace_meta, "..", p_owner->index);
}
return p_trace_meta;
}
static char* parse_path(char* path, char* name)
static char* parse_path(char* path, char* const name)
{
// skip extra '/'
while (*path == '/') {
@ -307,8 +83,9 @@ static char* parse_path(char* path, char* name)
// handle current name
int len = path - cur_start;
if (len >= RESOURCE_NAME_SIZE) {
strncpy(name, cur_start, RESOURCE_NAME_SIZE);
if (len >= TRACER_NODE_NAME_LEN) {
strncpy(name, cur_start, TRACER_NODE_NAME_LEN);
name[TRACER_NODE_NAME_LEN - 1] = '\0';
} else {
strncpy(name, cur_start, len);
name[len] = '\0';
@ -317,216 +94,101 @@ static char* parse_path(char* path, char* name)
return path;
}
static struct TraceMeta* tracer_find_meta(struct TraceMeta* const p_owner, char* path, int nameiparent, char* name)
static TracerNode* tracer_find_node_onestep(TracerNode* const owner, const char* const name)
{
struct TraceMeta* p_owner_inside = p_owner;
struct TraceMeta* vnp;
/* traverse TRACER_OWNER */
while ((path = parse_path(path, name)) != 0) {
if (p_owner_inside->type != TRACER_OWNER) {
return NULL;
}
if (nameiparent && *path == '\0') {
return p_owner_inside;
}
if ((vnp = tracer_find_meta_onestep(p_owner_inside, name, NULL)) == 0) {
DEBUG("Not such object: %s\n", path);
return NULL;
}
p_owner_inside = vnp;
}
if (nameiparent) {
return NULL;
}
return p_owner_inside;
}
int tracer_write_trace(struct TraceTag* const p_trace_tag, char* src, uint32_t off, uint32_t n)
{
if (src == NULL || p_trace_tag == NULL || p_trace_tag->meta == NULL) {
return -1;
}
return trace_write_info(p_trace_tag->meta, src, off, n);
}
int tracer_read_trace(struct TraceTag* const p_trace_tag, char* dst, uint32_t off, uint32_t n)
{
if (dst == NULL || p_trace_tag == NULL || p_trace_tag->meta == NULL) {
return -1;
}
return trace_read_info(p_trace_tag->meta, dst, off, n);
}
/// @brief
static void trace_locate_inner(struct TraceTag* target, struct TraceTag* const p_trace_tag, char* path, bool parent)
{
char name[RESOURCE_NAME_SIZE];
struct TraceMeta* p_trace_meta = tracer_find_meta(p_trace_tag->meta, path, parent, name);
// p_trace_meta: TRACER_OWNER, VT_FS or other.
// TRACER_OWNER: path: "", name: "dir name"
// other: path: "", name: "file name"
if (p_trace_meta == NULL) {
DEBUG("trace_locate, not found\n");
return;
}
target->type = p_trace_meta->type;
target->meta = p_trace_meta;
}
static inline void trace_locate(struct TraceTag* target, struct TraceTag* const p_trace_tag, char* path)
{
trace_locate_inner(target, p_trace_tag, path, 0);
}
static inline void trace_locate_parent(struct TraceTag* target, struct TraceTag* const p_trace_tag, char* path)
{
trace_locate_inner(target, p_trace_tag, path, 1);
}
bool tracer_create_trace(struct TraceTag* target, struct TraceTag* p_trace_tag, char* path, short type)
{
struct TraceMeta *p_trace_meta, *p_owner;
// find parent vfs inode
if ((p_owner = p_trace_tag->meta) == 0) {
LOG("create tracemeta failed, parent is null\n");
target->meta = NULL;
return false;
}
p_trace_meta = tracer_new_meta(p_owner, path, type);
target->meta = p_trace_meta;
return true;
}
bool tracer_delete_trace(struct TraceTag* target, struct TraceTag* owner)
{
if (target->meta == NULL || owner->type != TRACER_OWNER) {
return false;
}
struct TraceMeta* p_trace_meta = target->meta;
struct TraceMeta* p_owner_meta = owner->meta;
assert(p_trace_meta->type != TRACER_INVALID);
if (p_trace_meta->type == TRACER_OWNER) {
/// @todo support recursive delete
}
struct TraceResourceEntry resource_entry;
bool is_owned = false;
for (uint32_t off = 0; off < p_owner_meta->size; off += sizeof(resource_entry)) {
if (trace_read_info(p_owner_meta, (char*)&resource_entry, off, sizeof(resource_entry)) != sizeof(resource_entry)) {
panic("tracer_find_meta_onestep: read trace owner's resources failed\n");
}
if (resource_entry.index == 0) {
TracerNode* iter = NULL;
assert(owner->type == TRACER_OWNER);
DOUBLE_LIST_FOR_EACH_ENTRY(iter, &owner->children_guard, list_node)
{
if (iter->name == NULL) {
continue;
}
if (resource_entry.index == p_trace_meta->index) {
resource_entry.index = 0;
trace_write_info(owner->meta, (char*)&resource_entry, off, sizeof(resource_entry));
is_owned = true;
break;
if (strcmp(name, iter->name) == 0) {
return iter;
}
}
if (!is_owned) {
ERROR("delete trace(%d) not owned by given owner(%d).\n", target->meta->index, owner->meta->index);
return NULL;
}
TraceTag* const RequireRootTag()
{
return &sys_tracer.sys_tracer_tag;
}
bool AchieveResourceTag(TraceTag* target, TraceTag* owner, char* name)
{
static char name_buffer[TRACER_NODE_NAME_LEN];
TracerNode* inner_node = owner->meta;
assert(inner_node->type == TRACER_OWNER);
while ((name = parse_path(name, name_buffer)) != NULL) {
if ((inner_node = tracer_find_node_onestep(inner_node, name_buffer)) == NULL) {
DEBUG("Tracer: No such object, owner: %s, child: %s\n", //
owner->meta->name == NULL ? "NULL" : owner->meta->name, name == NULL ? "NULL" : name);
return false;
}
dealloc_trace_meta(p_trace_meta);
}
target->meta = inner_node;
return true;
}
void tracer_init(void)
void* AchieveResource(TraceTag* tag)
{
/* init sys_tracer, the manager */
spinlock_init(&sys_tracer.mem_chunk_bitmap_lock, "tracer_mem_chunk_bitmap");
spinlock_init(&sys_tracer.trace_meta_bitmap_lock, "tracer_meta_bitmap");
memset(sys_tracer.mem_chunks_bit_map, 0, sizeof(sys_tracer.mem_chunk_bitmap_lock));
memset(sys_tracer.trace_meta_bit_map, 0, sizeof(sys_tracer.trace_meta_bit_map));
assert((TRACER_MEM_CHUNK_SIZE % sizeof(struct TraceMeta)) == 0);
assert((TRACER_MEM_CHUNK_SIZE % sizeof(struct TraceResourceEntry)) == 0);
// mem_chunk space, fit with mem_chunk_bit_map
mem_chunk_synchronizer_init((uintptr_t)tracer_space, TRACER_MEM_CHUNK_SIZE, NR_TRACER_MEM_CHUNKS);
/* build root inode */
alloc_trace_meta(); // inode as guard.
/* build root trace_meta */
struct TraceMeta* root_tracemeta = alloc_trace_meta();
assert(root_tracemeta->index == 1);
root_tracemeta->type = TRACER_OWNER;
root_tracemeta->size = 0;
tracer_append_meta(root_tracemeta, ".", root_tracemeta->index);
tracer_append_meta(root_tracemeta, "..", root_tracemeta->index);
RequireRootTag()->meta = root_tracemeta;
}
/// @brief find resource tag
void tracer_find_tag(struct TraceTag* target, struct TraceTag* const source, char* path)
{
target->meta = NULL;
struct TraceTag* p_trace_tag;
if (*path == '/' || source == NULL) {
p_trace_tag = RequireRootTag();
} else {
p_trace_tag = source;
}
if (p_trace_tag == NULL || p_trace_tag->meta == NULL) {
return;
}
trace_locate(target, p_trace_tag, path);
}
bool AchieveResourceTag(struct TraceTag* target, struct TraceTag* owner, char* name)
{
tracer_find_tag(target, owner, name);
if (target->meta == NULL) {
return false;
}
return true;
}
void* AchieveResource(struct TraceTag* target)
{
if (target->type == TRACER_OWNER) {
assert(tag != NULL);
if (tag->meta == NULL || tag->meta->type == TRACER_OWNER) {
return NULL;
}
void* p_resource = NULL;
tracer_read_trace(target, (char*)&p_resource, 0, sizeof(void*));
assert(p_resource != NULL);
return p_resource;
return tag->meta->p_resource;
}
bool CreateResourceTag(struct TraceTag* new_tag, struct TraceTag* owner, char* name, tracemeta_ac_type type, void* p_resource)
bool CreateResourceTag(TraceTag* new_tag, TraceTag* owner, char* name, tracemeta_ac_type type, void* p_resource)
{
new_tag->type = type;
if (type == TRACER_OWNER) {
return tracer_create_trace(new_tag, owner, name, type);
assert(new_tag != NULL && owner != NULL);
if (owner->meta == NULL) {
ERROR("Tracer: Empty owner\n");
return false;
}
assert(owner->meta->type == TRACER_OWNER);
TracerNode* new_node = (TracerNode*)slab_alloc(&sys_tracer.node_allocator);
if (new_node == NULL) {
ERROR("Tracer: No memory for new node\n");
return false;
}
_tracer_init_node(new_node, name, type, p_resource);
// handle ac resource types
if (p_resource == NULL) {
// new node add to owner's children list
doubleListAddOnHead(&new_node->list_node, &owner->meta->children_guard);
new_node->parent = owner->meta;
new_tag->meta = new_node;
return true;
}
bool DeleteResource(TraceTag* target, TraceTag* owner)
{
assert(target != NULL && owner != NULL);
assert(owner->meta != NULL && owner->meta->type == TRACER_OWNER);
if (target->meta == NULL) {
ERROR("Tracer: Delete a empty resource\n");
return false;
}
if (!tracer_create_trace(new_tag, owner, name, type)) {
return false;
assert(target->meta->parent == owner->meta);
doubleListDel(&target->meta->list_node);
// delete name
if (target->meta->name != NULL) {
slab_free(&sys_tracer.node_name_allocator, target->meta->name);
}
bool ret = tracer_write_trace(new_tag, (char*)&p_resource, 0, sizeof(void*)) == sizeof(void*);
return ret;
}
bool DeleteResource(struct TraceTag* target, struct TraceTag* owner)
{
return tracer_delete_trace(target, owner);
// delete all children
/// @attention currently donot allow multilevel resource deletion
if (target->meta->type == TRACER_OWNER) {
assert(IS_DOUBLE_LIST_EMPTY(&target->meta->children_guard));
}
slab_free(&sys_tracer.node_allocator, target->meta);
target->meta = NULL;
return true;
}

64
Ubiquitous/XiZi_AIoT/kernel_actracer/actracer.h
View File

@ -30,8 +30,10 @@ Modification:
#include <stdbool.h>
#include <stdint.h>
#include "actracer_mem_chunk.h"
#include "spinlock.h"
#include "list.h"
#include "object_allocator.h"
#define TRACER_NODE_NAME_LEN 32
typedef enum {
TRACER_INVALID = 0,
@ -42,51 +44,31 @@ typedef enum {
TRACER_MEM_FROM_BUDDY_AC_RESOURCE,
} tracemeta_ac_type;
typedef uint16_t tracer_mem_chunk_idx_t;
#define TRACEMETA_NR_DIRECT 5
#define TRACEMETA_NR_INDIRECT 4
#define NR_ADDR_PER_MEM_CHUNK TRACER_MEM_CHUNK_SIZE / sizeof(tracer_mem_chunk_idx_t)
#define VFS_FILE_MAXSIZE (TRACEMETA_NR_DIRECT + (TRACEMETA_NR_INDIRECT * NR_ADDR_PER_MEM_CHUNK))
struct TraceMeta {
uint32_t size;
tracemeta_ac_type type; // TRACER_OWNER, etc.
uintptr_t reserved; // fast path to store pointer if content is a pointer
uint16_t index;
tracer_mem_chunk_idx_t addr[TRACEMETA_NR_DIRECT + TRACEMETA_NR_INDIRECT]; // 指向data mem_chunks, TRACER_OWNER 用于存放 dir entries, VT_FS用于存放bind
} __attribute__((aligned(32)));
typedef struct TracerNode {
tracemeta_ac_type type;
char* name;
union {
struct double_list_node children_guard;
void* p_resource;
};
struct TracerNode* parent;
struct double_list_node list_node;
} TracerNode;
/// @brief tag for other module to reference trace meta
struct TraceTag {
struct TraceMeta* meta;
short type; // TRACER_OWNER, etc.
};
#define RESOURCE_NAME_SIZE 14
struct TraceResourceEntry {
uint16_t index;
char name[RESOURCE_NAME_SIZE];
};
typedef struct TraceTag {
TracerNode* meta;
} TraceTag;
struct SysTracer {
#define NR_TRACER_MEM_CHUNKS 256
#define TRACER_MEM_CHUNK_SIZE sizeof(struct TraceMeta)
#define BITS_MEM_CHUNK_BITMAP (NR_TRACER_MEM_CHUNKS / 32)
uint32_t mem_chunks_bit_map[BITS_MEM_CHUNK_BITMAP];
struct spinlock mem_chunk_bitmap_lock;
#define NR_MAX_TRACEMETA 128
#define BITS_TRACEMETA_BITMAP (NR_MAX_TRACEMETA / 32)
uint32_t trace_meta_bit_map[BITS_TRACEMETA_BITMAP];
struct spinlock trace_meta_bitmap_lock;
struct TraceMeta trace_meta_poll[NR_MAX_TRACEMETA];
TracerNode root_node;
TraceTag sys_tracer_tag;
struct slab_allocator node_allocator;
struct slab_allocator node_name_allocator;
};
void tracer_init(void);
extern struct SysTracer sys_tracer;
extern struct TraceTag root_tracetag;
struct TraceTag* const RequireRootTag();
void sys_tracer_init();
TraceTag* const RequireRootTag();
bool AchieveResourceTag(struct TraceTag* target, struct TraceTag* owner, char* name);
void* AchieveResource(struct TraceTag* target);
bool CreateResourceTag(struct TraceTag* new_tag, struct TraceTag* owner, char* name, tracemeta_ac_type type, void* p_resource);

184
Ubiquitous/XiZi_AIoT/kernel_actracer/actracer_mem_chunk.c
View File

@ -1,184 +0,0 @@
/*
* Copyright (c) 2020 AIIT XUOS Lab
* XiUOS is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* http://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/**
* @file actracer_mem_chunk.c
* @brief tracer mem chunk implememntation
* @version 3.0
* @author AIIT XUOS Lab
* @date 2023.08.25
*/
/*************************************************
File name: actracer_mem_chunk.c
Description: tracer mem chunk implementation
Others:
History:
1. Date: 2023-08-28
Author: AIIT XUOS Lab
Modification:
1. first version
*************************************************/
#include <string.h>
#include "assert.h"
#include "spinlock.h"
#include "actracer.h"
#include "actracer_mem_chunk.h"
/// @brief to assert that a mem_chunk of memory will only write by one object
struct mem_chunk_synchronizer {
uintptr_t mem_chunk_base;
uint32_t mem_chunk_size;
uint32_t nr_mem_chunks;
struct spinlock lock;
struct tracer_mem_chunk mem_chunk_access_list[NR_MEM_CHUNK_CACHE];
struct double_list_node head;
};
static struct mem_chunk_synchronizer tracer_mem_chunk_syner;
static void tracer_mem_chunk_sync(struct tracer_mem_chunk* b)
{
if (!(b->flag & TRACER_MEM_CHUNK_BUSY)) {
panic("mem_chunk_sync: buf not busy");
}
if (b->chunk_id >= tracer_mem_chunk_syner.nr_mem_chunks) {
panic("mem_chunk_sync: sector out of range");
}
b->data = (uint8_t*)(tracer_mem_chunk_syner.mem_chunk_base + b->chunk_id * tracer_mem_chunk_syner.mem_chunk_size);
b->flag |= TRACER_MEM_CHUNK_VALID;
}
void mem_chunk_synchronizer_init(uintptr_t mem_chunk_base, uint32_t mem_chunk_size, uint32_t nr_mem_chunks)
{
tracer_mem_chunk_syner.mem_chunk_base = mem_chunk_base;
tracer_mem_chunk_syner.mem_chunk_size = mem_chunk_size;
tracer_mem_chunk_syner.nr_mem_chunks = nr_mem_chunks;
// Create linked list of buffers
doubleListNodeInit(&tracer_mem_chunk_syner.head);
for (struct tracer_mem_chunk* b = tracer_mem_chunk_syner.mem_chunk_access_list; b < tracer_mem_chunk_syner.mem_chunk_access_list + NR_MEM_CHUNK_CACHE; b++) {
doubleListNodeInit(&b->list_node);
doubleListAddOnHead(&b->list_node, &tracer_mem_chunk_syner.head);
}
}
static struct tracer_mem_chunk* tracer_get_mem_chunk_cache(uint32_t chunk_id)
{
// cached mem_chunk cache
struct tracer_mem_chunk* b;
DOUBLE_LIST_FOR_EACH_ENTRY(b, &tracer_mem_chunk_syner.head, list_node)
{
if (b->chunk_id == chunk_id) {
if (!(b->flag & TRACER_MEM_CHUNK_BUSY)) {
b->flag |= TRACER_MEM_CHUNK_BUSY;
return b;
}
}
}
// Non-cached mem_chunk cache
DOUBLE_LIST_FOR_EACH_ENTRY_REVERSE(b, &tracer_mem_chunk_syner.head, list_node)
{
if ((b->flag & TRACER_MEM_CHUNK_BUSY) == 0) {
b->chunk_id = chunk_id;
b->flag = TRACER_MEM_CHUNK_BUSY;
return b;
}
}
panic("tracer_get_mem_chunk_cache: no cache");
return NULL;
}
// Return a TRACER_MEM_CHUNK_BUSY buf with the contents of the indicated disk sector.
struct tracer_mem_chunk* tracer_mem_chunk_read(uint32_t chunk_id)
{
struct tracer_mem_chunk* b = tracer_get_mem_chunk_cache(chunk_id);
if (b == NULL) {
return NULL;
}
if (!(b->flag & TRACER_MEM_CHUNK_VALID)) {
tracer_mem_chunk_sync(b);
b->flag |= TRACER_MEM_CHUNK_VALID;
}
return b;
}
void tracer_mem_chunk_write(struct tracer_mem_chunk* b)
{
if ((b->flag & TRACER_MEM_CHUNK_BUSY) == 0) {
panic("tracer mem_chunk write a no busy mem_chunk");
}
tracer_mem_chunk_sync(b);
}
void tracer_mem_chunk_release(struct tracer_mem_chunk* b)
{
if ((b->flag & TRACER_MEM_CHUNK_BUSY) == 0) {
panic("tracer mem_chunk release but it's not busy occupied");
}
// move mem_chunk that just used to the head of cache list
doubleListDel(&b->list_node);
doubleListAddOnHead(&b->list_node, &tracer_mem_chunk_syner.head);
b->flag &= ~TRACER_MEM_CHUNK_BUSY;
}
static void tracer_mem_chunk_zero(uint32_t chunk_id)
{
assert(chunk_id >= 0 && chunk_id < tracer_mem_chunk_syner.nr_mem_chunks);
struct tracer_mem_chunk* tracer_mem_chunk = NULL;
tracer_mem_chunk = tracer_mem_chunk_read(chunk_id);
if (tracer_mem_chunk == NULL) {
return;
}
memset(tracer_mem_chunk->data, 0, tracer_mem_chunk_syner.mem_chunk_size);
tracer_mem_chunk_write(tracer_mem_chunk);
tracer_mem_chunk_release(tracer_mem_chunk);
}
/// @return mem_chunk_idx in bit_map
static uint32_t find_first_free_mem_chunk()
{
/// @todo another mem_chunk
for (uint32_t idx = 0; idx < BITS_MEM_CHUNK_BITMAP; idx++) {
if (sys_tracer.mem_chunks_bit_map[idx] == 0xFFFFFFFF) {
continue;
}
uint32_t position = __builtin_ffs(~sys_tracer.mem_chunks_bit_map[idx]);
if (position != 32) {
sys_tracer.mem_chunks_bit_map[idx] |= (1 << (position - 1));
return idx * 32 + position;
}
}
panic("Tracer no enough space.");
return 0;
}
uint32_t tracer_mem_chunk_alloc()
{
tracer_mem_chunk_idx_t idx = find_first_free_mem_chunk();
tracer_mem_chunk_zero(idx);
return idx;
}
void tracer_mem_chunk_free(uint32_t chunk_id)
{
assert(chunk_id >= 0 && chunk_id < NR_TRACER_MEM_CHUNKS);
uint32_t idx = chunk_id % 32;
uint32_t inner_mem_chunk_bit = chunk_id / 32;
// assert mem_chunk is allocated
assert((sys_tracer.mem_chunks_bit_map[idx] & (1 << inner_mem_chunk_bit)) != 0);
sys_tracer.mem_chunks_bit_map[idx] &= (uint32_t)(~(1 << inner_mem_chunk_bit));
}

54
Ubiquitous/XiZi_AIoT/kernel_actracer/actracer_mem_chunk.h
View File

@ -1,54 +0,0 @@
/*
* Copyright (c) 2020 AIIT XUOS Lab
* XiUOS is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* http://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/**
* @file actracer_mem_chunk.h
* @brief tracer mem chunk header
* @version 3.0
* @author AIIT XUOS Lab
* @date 2023.08.25
*/
/*************************************************
File name: actracer_mem_chunk.h
Description: tracer mem chunk header
Others:
History:
1. Date: 2023-08-28
Author: AIIT XUOS Lab
Modification:
1. first version
*************************************************/
#pragma once
#include <stdint.h>
#include "list.h"
#define NR_MEM_CHUNK_CACHE 128
typedef enum {
TRACER_MEM_CHUNK_BUSY = 0x1,
TRACER_MEM_CHUNK_VALID = 0x2,
} tracer_mem_chunk_flag;
struct tracer_mem_chunk {
tracer_mem_chunk_flag flag;
uint32_t chunk_id;
struct double_list_node list_node;
uint8_t* data;
};
void mem_chunk_synchronizer_init(uintptr_t mem_chunk_base, uint32_t mem_chunk_size, uint32_t nr_mem_chunks);
struct tracer_mem_chunk* tracer_mem_chunk_read(uint32_t chunk_id);
void tracer_mem_chunk_write(struct tracer_mem_chunk* b);
void tracer_mem_chunk_release(struct tracer_mem_chunk* b);
uint32_t tracer_mem_chunk_alloc();
void tracer_mem_chunk_free(uint32_t chunk_id);

1
Ubiquitous/XiZi_AIoT/softkernel/include/object_allocator.h
View File

@ -29,6 +29,7 @@ Modification:
*************************************************/
#pragma once
#include <stddef.h>
#include <stdint.h>
struct slab_state {

2
Ubiquitous/XiZi_AIoT/softkernel/init/softkernel_init.c
View File

@ -40,8 +40,6 @@ bool softkernel_init(struct TraceTag* _hardkernel_tag, struct TraceTag* _softker
CreateResourceTag(&server_identifier_owner, _softkernel_tag, "server-identifier", TRACER_OWNER, NULL);
/* init soft kernel */
module_phymem_init(); // init buddy management system
struct PagerRightGroup pager_rights;
AchieveResourceTag(&pager_rights.mmu_driver_tag, _hardkernel_tag, "mmu-ac-resource");
module_pager_init(&pager_rights);

8
Ubiquitous/XiZi_AIoT/softkernel/main.c
View File

@ -33,6 +33,7 @@ Modification:
#include "multicores.h"
#include "assert.h"
#include "kalloc.h"
#include "task.h"
struct spinlock whole_kernel_lock;
@ -42,13 +43,16 @@ extern int sys_spawn(char* img_start, char* name, char** argv);
static struct TraceTag hardkernel_tag, softkernel_tag;
static volatile int core_init_done = 0;
__attribute__((optimize("O0"))) int main(void)
int main(void)
{
/* init tracer */
uint32_t cpu_id = cur_cpuid();
if (cpu_id == 0) {
tracer_init(); // init tracer system
/* init memory management first */
module_phymem_init(); // init buddy management system
/* init tracer system */
sys_tracer_init();
if (!CreateResourceTag(&hardkernel_tag, RequireRootTag(), "hardkernel", TRACER_OWNER, NULL) || //
!CreateResourceTag(&softkernel_tag, RequireRootTag(), "softkernel", TRACER_OWNER, NULL)) {
ERROR("Failed to create hardkernel owner and softkernel owner.\n");

4
Ubiquitous/XiZi_AIoT/softkernel/memory/kalloc.c
View File

@ -39,14 +39,14 @@ struct KBuddy user_phy_freemem_buddy;
extern uint32_t kernel_data_end[];
bool module_phymem_init()
{
LOG_PRINTF("Organizing free memory...\n");
// LOG_PRINTF("Organizing free memory...\n");
uint32_t kern_freemem_start = V2P(&kernel_data_end);
uint32_t kern_freemem_end = PHY_USER_FREEMEM_BASE;
uint32_t user_freemem_start = PHY_USER_FREEMEM_BASE;
uint32_t user_freemem_end = PHY_MEM_STOP;
KBuddySysInit(&kern_virtmem_buddy, kern_freemem_start, kern_freemem_end);
KBuddyInit(&user_phy_freemem_buddy, user_freemem_start, user_freemem_end);
LOG_PRINTF("Free memory organized done.\n");
// LOG_PRINTF("Free memory organized done.\n");
return true;
}

2
Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_connect_session.c
View File

@ -67,7 +67,7 @@ int sys_connect_session(char* path, int capacity, struct Session* user_session)
if (!AchieveResourceTag(&server_identifier_owner, RequireRootTag(), "softkernel/server-identifier")) {
panic("Server identifier not initialized.\b");
}
assert(server_identifier_owner.meta != NULL || server_identifier_owner.type == TRACER_OWNER);
assert(server_identifier_owner.meta != NULL);
struct TraceTag server_tag;
if (!AchieveResourceTag(&server_tag, &server_identifier_owner, path)) {

2
Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_register_as_server.c
View File

@ -44,7 +44,7 @@ int sys_register_as_server(char* name)
if (!AchieveResourceTag(&server_identifier_set_tag, RequireRootTag(), "softkernel/server-identifier")) {
panic("Server identifier not initialized.\b");
}
assert(server_identifier_set_tag.meta != NULL || server_identifier_set_tag.type == TRACER_OWNER);
assert(server_identifier_set_tag.meta != NULL);
if (!CreateResourceTag(&server->server_identifier, &server_identifier_set_tag, name, TRACER_SERVER_IDENTITY_AC_RESOURCE, server)) {
return -1;