forked from xuos/xiuos
153 lines
4.9 KiB
C
153 lines
4.9 KiB
C
/*
|
|
* 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 sys_state.c
|
|
* @brief task ask for kernel status(for debug perpose)
|
|
* @version 3.0
|
|
* @author AIIT XUOS Lab
|
|
* @date 2023.08.25
|
|
*/
|
|
|
|
/*************************************************
|
|
File name: sys_state.c
|
|
Description: task ask for kernel status(for debug perpose)
|
|
Others:
|
|
History:
|
|
1. Date: 2023-08-28
|
|
Author: AIIT XUOS Lab
|
|
Modification:
|
|
1. first version
|
|
*************************************************/
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
|
|
#include "assert.h"
|
|
#include "buddy.h"
|
|
#include "log.h"
|
|
#include "multicores.h"
|
|
#include "pagetable.h"
|
|
#include "syscall.h"
|
|
#include "task.h"
|
|
|
|
extern uint8_t _binary_fs_img_start[], _binary_fs_img_end[];
|
|
|
|
/// @brief Padding task name length to TASK_NAME_MAX_LEN
|
|
static inline void _padding(char* name)
|
|
{
|
|
int i;
|
|
size_t length = strlen(name);
|
|
for (i = length; i < TASK_NAME_MAX_LEN - 1; i++) {
|
|
name[i] = ' ';
|
|
}
|
|
name[i] = '\0';
|
|
return;
|
|
}
|
|
|
|
void show_tasks(void)
|
|
{
|
|
struct TaskMicroDescriptor* task = NULL;
|
|
LOG_PRINTF("******************************************************\n");
|
|
for (int i = 0; i < NR_CPU; i++) {
|
|
LOG_PRINTF("CPU %d: ", i);
|
|
if (global_cpus[i].task != NULL) {
|
|
LOG_PRINTF("%s\n", global_cpus[i].task->name);
|
|
} else {
|
|
LOG_PRINTF("NULL\n");
|
|
}
|
|
}
|
|
LOG_PRINTF("******************************************************\n");
|
|
LOG_PRINTF("STAT ID TASK PRI MEM(KB)\n");
|
|
for (int i = 0; i < TASK_MAX_PRIORITY; i++) {
|
|
if (IS_DOUBLE_LIST_EMPTY(&xizi_task_manager.task_list_head[i])) {
|
|
continue;
|
|
}
|
|
DOUBLE_LIST_FOR_EACH_ENTRY(task, &xizi_task_manager.task_list_head[i], node)
|
|
{
|
|
if (task->state == INIT)
|
|
LOG_PRINTF(" INIT ");
|
|
else if (task->state == READY)
|
|
LOG_PRINTF(" READY ");
|
|
else if (task->state == RUNNING)
|
|
LOG_PRINTF("RUNNING ");
|
|
else if (task->state == DEAD)
|
|
LOG_PRINTF(" DEAD ");
|
|
|
|
_padding(task->name);
|
|
LOG_PRINTF(" %d %s %d %d\n", task->pid, task->name, task->priority, task->mem_size >> 10);
|
|
}
|
|
}
|
|
LOG_PRINTF("******************************************************\n");
|
|
return;
|
|
}
|
|
|
|
extern struct KBuddy user_phy_freemem_buddy;
|
|
extern struct KBuddy kern_virtmem_buddy;
|
|
extern uint32_t kernel_data_end[];
|
|
void show_mem(void)
|
|
{
|
|
LOG_PRINTF("*********************************************************\n");
|
|
LOG_PRINTF(" TOTAL(KB) USED(KB) FREE(KB) \n");
|
|
|
|
uint32_t total = (PHY_MEM_STOP - V2P(kernel_data_end)) >> 10;
|
|
uint32_t used = 0;
|
|
for (int j = 0; j < MAX_BUDDY_ORDER; j++) {
|
|
used += user_phy_freemem_buddy.free_list[j].n_free_pages * (1 << j) * PAGE_SIZE;
|
|
used += kern_virtmem_buddy.free_list[j].n_free_pages * (1 << j) * PAGE_SIZE;
|
|
}
|
|
used = used >> 10;
|
|
|
|
LOG_PRINTF(" %d %d %d\n", total, total - used, used);
|
|
LOG_PRINTF("*********************************************************\n");
|
|
return;
|
|
}
|
|
|
|
void show_cpu(void)
|
|
{
|
|
LOG_PRINTF("**********************************************************\n");
|
|
#ifdef ARCH_SMP
|
|
/// @todo support smp
|
|
KPrintf(" cpu VALUE \n");
|
|
#endif
|
|
|
|
int cpu_id = 0;
|
|
|
|
struct TaskMicroDescriptor* current_task = cur_cpu()->task;
|
|
assert(current_task != NULL);
|
|
|
|
_padding(current_task->name);
|
|
|
|
LOG_PRINTF(" ID COMMAND USED_TICKS FREE_TICKS \n");
|
|
LOG_PRINTF(" %d %s %d %d\n", cpu_id, current_task->name, TASK_CLOCK_TICK - current_task->remain_tick, current_task->remain_tick);
|
|
|
|
LOG_PRINTF("***********************************************************\n");
|
|
return;
|
|
}
|
|
|
|
int sys_state(sys_state_option option, sys_state_info* info)
|
|
{
|
|
if (option == SYS_STATE_MEMBLOCK_INFO) {
|
|
info->memblock_info.memblock_start = (uintptr_t)V2P(_binary_fs_img_start);
|
|
info->memblock_info.memblock_end = (uintptr_t)V2P(_binary_fs_img_end);
|
|
} else if (option == SYS_STATE_GET_HEAP_BASE) {
|
|
return cur_cpu()->task->heap_base;
|
|
} else if (option == SYS_STATE_SET_TASK_PRIORITY) {
|
|
xizi_task_manager.set_cur_task_priority(info->priority);
|
|
} else if (option == SYS_STATE_SHOW_TASKS) {
|
|
show_tasks();
|
|
} else if (option == SYS_STATE_SHOW_MEM_INFO) {
|
|
show_mem();
|
|
} else if (option == SYS_STATE_SHOW_CPU_INFO) {
|
|
show_cpu();
|
|
}
|
|
|
|
return 0;
|
|
} |