OpenXX/xiuos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use new sys tracer.

Browse Source
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
Download Patch File Download Diff File Expand all files Collapse all files

540
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;
}
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;
}
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;
}
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 false;
}
dealloc_trace_meta(p_trace_meta);
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;
}
}
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;
}