floratest5
/
xiuos
forked from xuos/xiuos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
xiuos/Ubiquitous/XiUOS/tool/shell/letter-shell/cmd.c

550 lines
18 KiB
C
Raw Blame History

/*
* 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.
*/
#include <xiuos.h>
#include "shell.h"
#include <bus.h>
#include <xs_ktask_stat.h>
#include <string.h>
long Hello(void)
{
KPrintf("Hello World!\n");
return 0;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_PARAM_NUM(0)|SHELL_CMD_DISABLE_RETURN, Hello, Hello, show Hello World information);
extern void ShowBanner(void);
long ShowVersion(void)
{
ShowBanner();
return 0;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_PARAM_NUM(0)|SHELL_CMD_DISABLE_RETURN, ShowVersion, ShowVersion, show XiUOS version information);
static __inline void PrintSpace(int len)
{
while (len--) KPrintf(" ");
}
extern DoubleLinklistType xiaoshan_task_head;
#ifdef KERNEL_SEMAPHORE
extern DoubleLinklistType k_sem_list;
#endif
#ifdef KERNEL_MUTEX
extern DoubleLinklistType k_mutex_list;
#endif
#ifdef KERNEL_EVENT
extern DoubleLinklistType k_event_list;
#endif
#ifdef KERNEL_MESSAGEQUEUE
extern DoubleLinklistType k_mq_list;
#endif
#ifdef KERNEL_SOFTTIMER
extern DoubleLinklistType k_timer_list;
#endif
#ifdef KERNEL_MEMBLOCK
extern DoubleLinklistType xiaoshan_memgather_head;
#endif
extern DoubleLinklistType bus_linklist;
long ShowTask(void)
{
int k = 0;
x_ubase lock = 0;
uint8 stat = 0;
uint8 *ptr = NONE;
const char *item_title = "TASK";
struct TaskDescriptor *task = NONE;
DoubleLinklistType *nodelink = NONE;
KPrintf("*************************************************************************************************\n");
#ifdef ARCH_SMP
for(k = 0;k < CPU_NUMBERS; k++){
KPrintf(" CPU[%d] CURRENT RUNNING TASK[ %s ] PRI[ %d ] \n",k,Assign.smp_os_running_task[k]->task_base_info.name,Assign.smp_os_running_task[k]->task_dync_sched_member.cur_prio);
}
#else
KPrintf(" CURRENT RUNNING TASK[ %s ] PRI[ %d ]\n",Assign.os_running_task->task_base_info.name,Assign.os_running_task->task_dync_sched_member.cur_prio);
#endif
#ifdef SCHED_POLICY_RR_REMAINSLICE
KPrintf(" SCHED POLICY [ RR_REMAINSLICE ]\n");
#endif
#ifdef SCHED_POLICY_RR
KPrintf(" SCHED POLICY [ RR ]\n");
#endif
#ifdef SCHED_POLICY_FIFO
KPrintf(" SCHED POLICY [ FIFO ]\n");
#endif
KPrintf("*************************************************************************************************\n");
#ifndef SCHED_POLICY_FIFO
#ifdef ARCH_SMP
KPrintf(" STAT ID %-*.s PRI CORE STACK_DEPTH USED LEFT_TICKS ERROR_STAT\n", NAME_NUM_MAX, item_title);
#else
KPrintf(" STAT ID %-*.s PRI STACK_DEPTH USED LEFT_TICKS ERROR_STAT\n", NAME_NUM_MAX, item_title);
#endif
#else
#ifdef ARCH_SMP
KPrintf(" STAT ID %-*.s PRI CORE STACK_DEPTH USED ERROR_STAT\n", NAME_NUM_MAX, item_title);
#else
KPrintf(" STAT ID %-*.s PRI STACK_DEPTH USED ERROR_STAT\n", NAME_NUM_MAX, item_title);
#endif
#endif
lock = CriticalAreaLock();
DOUBLE_LINKLIST_FOR_EACH(nodelink, &xiaoshan_task_head) {
task = CONTAINER_OF(nodelink, struct TaskDescriptor, link);
if(NONE != task) {
stat = KTaskStatGet(task);
if (stat == KTASK_READY) KPrintf(" READY ");
else if (stat == KTASK_SUSPEND) KPrintf(" SUSPEND");
else if (stat == KTASK_INIT) KPrintf(" INIT ");
else if (stat == KTASK_CLOSE) KPrintf(" CLOSE ");
else if (stat == KTASK_RUNNING) KPrintf(" RUNNING");
#ifdef ARCH_SMP
KPrintf("%3d %-*.*s %3d %3d ", task->id.id,NAME_NUM_MAX, NAME_NUM_MAX, task->task_base_info.name, task->task_dync_sched_member.cur_prio,task->task_smp_info.runing_coreid );
#else
KPrintf("%3d %-*.*s %3d ", task->id.id,NAME_NUM_MAX, NAME_NUM_MAX, task->task_base_info.name, task->task_dync_sched_member.cur_prio);
#endif
#ifndef SCHED_POLICY_FIFO
ptr = (uint8 *)task->task_base_info.stack_start;
while (*ptr == '#')ptr ++;
KPrintf(" %-10d%d%% %-10d%04d\n",
task->task_base_info.stack_depth,
(task->task_base_info.stack_depth - ((x_ubase) ptr - (x_ubase) task->task_base_info.stack_start)) * 100 / task->task_base_info.stack_depth,
task->task_dync_sched_member.rest_timeslice, task->exstatus);
#else
ptr = (uint8 *)task->task_base_info.stack_start;
while (*ptr == '#')ptr ++;
KPrintf(" %-10d%d%% %04d\n",
task->task_base_info.stack_depth,
(task->task_base_info.stack_depth - ((x_ubase) ptr - (x_ubase) task->task_base_info.stack_start)) * 100 / task->task_base_info.stack_depth, task->exstatus);
#endif
}
}
CriticalAreaUnLock(lock);
KPrintf("*************************************************************************************************\n");
return 0;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_PARAM_NUM(0)|SHELL_CMD_DISABLE_RETURN, ShowTask, ShowTask, show task information in XiUOS);
static void GetSuspendedTask(struct SysDoubleLinklistNode *list)
{
struct TaskDescriptor *task = NONE;
DoubleLinklistType *nodelink = NONE;
DOUBLE_LINKLIST_FOR_EACH(nodelink, list){
task = CONTAINER_OF(nodelink, struct TaskDescriptor, task_dync_sched_member.sched_link);
if(NONE != task) {
KPrintf("%s | ", task->task_base_info.name);
}
}
}
#ifdef KERNEL_SEMAPHORE
long ShowSem(void)
{
x_base lock = 0;
struct Semaphore *sem = NONE;
DoubleLinklistType *nodelink = NONE;
KPrintf("******************************************************************\n");
KPrintf(" SEM_ID VALUE SUSPEND_TASK\n");
lock = CriticalAreaLock();
DOUBLE_LINKLIST_FOR_EACH(nodelink, &k_sem_list) {
sem = CONTAINER_OF(nodelink, struct Semaphore, link);
if(NONE != sem) {
if (!IsDoubleLinkListEmpty(&sem->pend_list)) {
KPrintf(" %-8d%-8d :", sem->id.id, sem->value);
GetSuspendedTask(&(sem->pend_list));
KPrintf("\n");
} else {
KPrintf(" %-8d%-8d NONE\n", sem->id.id, sem->value);
}
}
}
CriticalAreaUnLock(lock);
KPrintf("******************************************************************\n");
return 0;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_PARAM_NUM(0)|SHELL_CMD_DISABLE_RETURN, ShowSem, ShowSem, show sem information in XiUOS);
#endif
#ifdef KERNEL_EVENT
long ShowEvent(void)
{
x_base lock = 0;
struct Event *event = NONE;
DoubleLinklistType *nodelink = NONE;
KPrintf("******************************************************************\n");
KPrintf(" EVENT_ID OPTIONS EVENTS SUSPEND_TASK\n");
lock = CriticalAreaLock();
DOUBLE_LINKLIST_FOR_EACH(nodelink, &k_event_list) {
event = CONTAINER_OF(nodelink, struct Event, link);
if(NONE != event) {
if (!IsDoubleLinkListEmpty(&event->pend_list)) {
KPrintf(" %-8d0x%-8x0x%-12x", event->id.id, event->options, event->events);
GetSuspendedTask(&(event->pend_list));
KPrintf("\n");
} else {
KPrintf(" %-8d0x%-8x0x%-12x NONE\n", event->id.id, event->options, event->events);
}
}
}
CriticalAreaUnLock(lock);
KPrintf("******************************************************************\n");
return 0;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_PARAM_NUM(0)|SHELL_CMD_DISABLE_RETURN, ShowEvent, ShowEvent, show event information in XiUOS);
#endif
#ifdef KERNEL_MUTEX
long ShowMutex(void)
{
x_base lock = 0;
struct Mutex *mutex = NONE;
DoubleLinklistType *nodelink = NONE;
KPrintf("******************************************************************\n");
KPrintf("MUTEX_ID HOLDER RECRUSIVE_CNT SUSPEND_TASK\n");
lock = CriticalAreaLock();
DOUBLE_LINKLIST_FOR_EACH(nodelink, &k_mutex_list) {
mutex = CONTAINER_OF(nodelink, struct Mutex, link);
if(NONE != mutex) {
if (!IsDoubleLinkListEmpty(&mutex->pend_list)) {
KPrintf(" %-8d%-10s%-12d", mutex->id.id, (mutex->holder == NONE ?"NONE":(mutex->holder->task_base_info.name)), mutex->recursive_cnt);
GetSuspendedTask(&(mutex->pend_list));
KPrintf("\n");
} else {
KPrintf(" %-8d%-10s%-12d NONE\n", mutex->id.id, (mutex->holder == NONE ?"NONE":(mutex->holder->task_base_info.name)), mutex->recursive_cnt);
}
}
}
CriticalAreaUnLock(lock);
KPrintf("******************************************************************\n");
return 0;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_PARAM_NUM(0)|SHELL_CMD_DISABLE_RETURN, ShowMutex, ShowMutex, show mutex information in XiUOS);
#endif
#ifdef KERNEL_MESSAGEQUEUE
long ShowMsgQueue(void)
{
x_base lock = 0;
struct MsgQueue *msgq = NONE;
DoubleLinklistType *nodelink = NONE;
KPrintf("****************************************************************************************\n");
KPrintf(" MSG_ID NUM_MSGS EACH_LEN MAX_MSGS %-32s%s\n","SEND_SUSPEND_TASK","RECV_SUSPEND_TASK");
lock = CriticalAreaLock();
DOUBLE_LINKLIST_FOR_EACH(nodelink, &k_mq_list) {
msgq = CONTAINER_OF(nodelink, struct MsgQueue, link);
if(NONE != msgq) {
KPrintf(" %-8d%-8d%-8d%-8d", msgq->id.id, msgq->num_msgs, msgq->each_len,msgq->max_msgs);
if (!IsDoubleLinkListEmpty(&msgq->send_pend_list)) {
GetSuspendedTask(&(msgq->send_pend_list));
} else {
PrintSpace(32);
}
if (!IsDoubleLinkListEmpty(&msgq->recv_pend_list)){
GetSuspendedTask(&(msgq->recv_pend_list));
}
KPrintf("\n");
}
}
CriticalAreaUnLock(lock);
KPrintf("****************************************************************************************\n");
return 0;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_PARAM_NUM(0)|SHELL_CMD_DISABLE_RETURN, ShowMsgQueue, ShowMsgQueue, show msg queue information in XiUOS);
#endif
#ifdef KERNEL_MEMBLOCK
long ShowGatherMem(void)
{
x_base lock = 0;
struct MemGather *mg = NONE;
DoubleLinklistType *nodelink = NONE;
KPrintf("****************************************************************************************\n");
KPrintf("GATHERMEM BLOCK TOTAL FREE SUSPEND_TASK\n");
lock = CriticalAreaLock();
DOUBLE_LINKLIST_FOR_EACH(nodelink, &xiaoshan_memgather_head) {
mg = CONTAINER_OF(nodelink, struct MemGather, m_link);
if(NONE != mg) {
if (!IsDoubleLinkListEmpty(&mg->wait_task)) {
KPrintf(" %-8s%-6d%-6d%-6d :",
mg->m_name,
mg->one_block_size,
mg->block_total_number,
mg->block_free_number);
GetSuspendedTask(&(mg->wait_task));
KPrintf("\n");
} else {
KPrintf(" %-8s%-6d%-6d%-6d NONE\n",
mg->m_name,
mg->one_block_size,
mg->block_total_number,
mg->block_free_number);
}
}
}
CriticalAreaUnLock(lock);
KPrintf("****************************************************************************************\n");
return 0;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_PARAM_NUM(0)|SHELL_CMD_DISABLE_RETURN, ShowGatherMem, ShowGatherMem, show mem block information in XiUOS);
#endif
#ifdef KERNEL_SOFTTIMER
long ShowTimer(void)
{
x_base lock = 0;
struct Timer *timer = NONE;
DoubleLinklistType *nodelink = NONE;
KPrintf("****************************************************************************************\n");
KPrintf(" TIMER_ID NAME STATUS PERIODIC DEADLINE\n");
lock = CriticalAreaLock();
DOUBLE_LINKLIST_FOR_EACH(nodelink, &k_timer_list) {
timer = CONTAINER_OF(nodelink, struct Timer, link);
if(NONE != timer) {
KPrintf(" %-8d%-8s%-10s%-10d%d\n", timer->id_node.id, timer->name, (timer->active_status == TIMER_ACTIVE_TRUE ? "active" : "unactive"),timer->origin_timeslice,timer->deadline_timeslice);
}
}
CriticalAreaUnLock(lock);
KPrintf("****************************************************************************************\n");
return 0;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_PARAM_NUM(0)|SHELL_CMD_DISABLE_RETURN, ShowTimer, ShowTimer, show timer information in XiUOS);
#endif
static char *const bus_type_str[] =
{
"I2C_BUS",
"SPI_BUS",
"HWT_BUS",
"USB_BUS",
"CAN_BUS",
"WDT_BUS",
"SDIO_BUS",
"TOUCH_BUS",
"LCD_BUS",
"PIN_BUS",
"RTC_BUS",
"SERIAL_BUS",
"ADC_BUS",
"Unknown"
};
static DriverType ShowBusFindDriver(struct Bus *bus)
{
struct Driver *driver = NONE;
DoubleLinklistType *node = NONE;
DoubleLinklistType *head = &bus->bus_drvlink;
for(node = head->node_next; node != head; node = node->node_next) {
driver = SYS_DOUBLE_LINKLIST_ENTRY(node, struct Driver, driver_link);
return driver;
}
return NONE;
}
long ShowBus(void)
{
BusType bus;
DriverType driver;
HardwareDevType device;
DoubleLinklistType *bus_node = NONE;
DoubleLinklistType *bus_head = &bus_linklist;
int i = 0;
int dev_cnt, maxlen;
const char *item_type = "bus_type";
const char *item_name_0 = "bus_name";
const char *item_name_1 = "drv_name";
const char *item_name_2 = "dev_name";
const char *item_cnt = "cnt";
KPrintf(" %-15s%-15s%-15s%-15s%-20s\n", item_type, item_name_0, item_name_1, item_name_2, item_cnt);
maxlen = 65;
while (i < maxlen) {
i++;
if (maxlen == i) {
KPrintf("-\n");
} else {
KPrintf("-");
}
}
bus_node = bus_head->node_next;
do
{
bus = SYS_DOUBLE_LINKLIST_ENTRY(bus_node, struct Bus, bus_link);
if (bus) {
KPrintf("%s", " ");
KPrintf("%-15s%-15s",
bus_type_str[bus->bus_type],
bus->bus_name);
driver = ShowBusFindDriver(bus);
if (driver) {
KPrintf("%-15s", driver->drv_name);
} else {
KPrintf("%-15s", "nil");
}
if (bus->haldev_cnt) {
DoubleLinklistType *dev_node = NONE;
DoubleLinklistType *dev_head = &bus->bus_devlink;
dev_node = dev_head->node_next;
dev_cnt = 1;
while (dev_node != dev_head) {
device = SYS_DOUBLE_LINKLIST_ENTRY(dev_node, struct HardwareDev, dev_link);
if (1 == dev_cnt) {
if (device) {
KPrintf("%-16s%-4d\n", device->dev_name, dev_cnt);
} else {
KPrintf("%-16s%-4d\n", "nil", dev_cnt);
}
} else {
KPrintf("%46s", " ");
if (device) {
KPrintf("%-16s%-4d\n", device->dev_name, dev_cnt);
} else {
KPrintf("%-16s%-4d\n", "nil", dev_cnt);
}
}
dev_cnt++;
dev_node = dev_node->node_next;
}
} else {
KPrintf("\n");
}
}
bus_node = bus_node->node_next;
}
while (bus_node != bus_head);
return 0;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_PARAM_NUM(1)|SHELL_CMD_DISABLE_RETURN,ShowBus, ShowBus, show bus information in XiUOS);
#ifdef RESOURCES_RTC
#include "bus_rtc.h"
static void SetDateAndTime(char argc, char **argv)
{
if (1 == argc) {
time_t now;
now = time(NONE);
KPrintf("%s", ctime(&now));
} else if (argc >= 7) {
struct RtcSetParam rtc_set_param;
rtc_set_param.rtc_set_cmd = OPER_RTC_SET_TIME;
uint16 year;
uint8 month, day, hour, min, sec;
year = atoi(argv[1]);
month = atoi(argv[2]);
day = atoi(argv[3]);
hour = atoi(argv[4]);
min = atoi(argv[5]);
sec = atoi(argv[6]);
if (year > 2099 || year < 2000) {
KPrintf("year is out of range [2000-2099]\n");
return;
}
if (month == 0 || month > 12) {
KPrintf("month is out of range [1-12]\n");
return;
}
if (day == 0 || day > 31) {
KPrintf("day is out of range [1-31]\n");
return;
}
if (hour > 23) {
KPrintf("hour is out of range [0-23]\n");
return;
}
if (min > 59) {
KPrintf("minute is out of range [0-59]\n");
return;
}
if (sec > 59) {
KPrintf("second is out of range [0-59]\n");
return;
}
rtc_set_param.date_param.year = year;
rtc_set_param.date_param.month = month;
rtc_set_param.date_param.day = day;
rtc_set_param.time_param.hour = hour;
rtc_set_param.time_param.minute = min;
rtc_set_param.time_param.second = sec;
RtcDrvSetFunction(RTC_DRV_NAME, &rtc_set_param);
} else {
KPrintf("only support input [year month day hour min sec]\n");
}
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN)|SHELL_CMD_PARAM_NUM(9), SetDateAndTime, SetDateAndTime, set date and time using rtc function);
#endif
Reference in New Issue View Git Blame Copy Permalink