rel_1.6.0 init

Living_SDK/tools/cli/cli.mk

@@ -0,0 +1,17 @@
+NAME := cli
+
+$(NAME)_TYPE := kernel
+$(NAME)_MBINS_TYPE := kernel
+
+$(NAME)_SOURCES := cli.c dumpsys.c
+
+ifeq ($(COMPILER),armcc)
+else ifeq ($(COMPILER),iar)
+else
+$(NAME)_CFLAGS  += -Wall -Werror
+endif
+
+$(NAME)_COMPONENTS += hal
+
+GLOBAL_INCLUDES += include
+GLOBAL_DEFINES  += HAVE_NOT_ADVANCED_FORMATE

Living_SDK/tools/cli/dumpsys.c

@@ -0,0 +1,468 @@
+/*
+ * Copyright (C) 2015-2017 Alibaba Group Holding Limited
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include <aos/aos.h>
+
+#ifdef VCALL_RHINO
+#include "k_api.h"
+
+#define MM_LEAK_CHECK_ROUND_SCOND 10 * 1000
+#define RHINO_BACKTRACE_DEPTH 10
+
+extern char esc_tag[64];
+
+#if (RHINO_CONFIG_MM_LEAKCHECK > 0)
+extern uint32_t dump_mmleak(void);
+#endif
+
+ktimer_t g_mm_leak_check_timer;
+
+#define safesprintf(buf, totallen, offset, string)                \
+    do                                                            \
+    {                                                             \
+        if ((totallen - offset) <= strlen(string))                \
+        {                                                         \
+            csp_printf("%s", buf);                                \
+            offset = 0;                                           \
+        }                                                         \
+        snprintf(buf + offset, strlen(string) + 1, "%s", string); \
+        offset += strlen(string);                                 \
+    } while (0)
+
+int dump_task_stack_byname(char *taskname);
+
+uint32_t dumpsys_task_func(char *buf, uint32_t len, int detail)
+{
+    kstat_t rst;
+    size_t free_size = 0;
+    sys_time_t time_total = 0;
+    /* consistent with "task_stat_t" */
+    char *cpu_stat[] = {"ERROR", "RDY", "PEND", "SUS",
+                        "PEND_SUS", "SLP",
+                        "SLP_SUS", "DELETED"};
+    klist_t *taskhead = &g_kobj_list.task_head;
+    klist_t *taskend = taskhead;
+    klist_t *tmp;
+    ktask_t *task;
+    ktask_t *candidate;
+    char yes = 'N';
+    char *printbuf = NULL;
+    char tmpbuf[256] = {0};
+    int offset = 0;
+    int totallen = 2048;
+    int taskstate = 0;
+
+    printbuf = aos_malloc(totallen);
+    if (printbuf == NULL)
+    {
+        return RHINO_NO_MEM;
+    }
+    memset(printbuf, 0, totallen);
+
+    krhino_sched_disable();
+    preferred_cpu_ready_task_get(&g_ready_queue, cpu_cur_get());
+    candidate = g_preferred_ready_task[cpu_cur_get()];
+
+    snprintf(tmpbuf, 255,
+             "%s------------------------------------------------------------------------\r\n",
+             esc_tag);
+    safesprintf(printbuf, totallen, offset, tmpbuf);
+
+#if (RHINO_CONFIG_CPU_USAGE_STATS > 0)
+    snprintf(tmpbuf, 255, "%sCPU usage :%-10d                    \n",
+             esc_tag, g_cpu_usage / 100);
+    safesprintf(printbuf, totallen, offset, tmpbuf);
+    snprintf(tmpbuf, 255,
+             "%s------------------------------------------------------------------------\r\n",
+             esc_tag);
+    safesprintf(printbuf, totallen, offset, tmpbuf);
+
+#endif
+    snprintf(tmpbuf, 255,
+             "%sName               State    Prio StackSize MinFreesize Runtime Candidate\r\n",
+             esc_tag);
+    safesprintf(printbuf, totallen, offset, tmpbuf);
+    snprintf(tmpbuf, 255,
+             "%s------------------------------------------------------------------------\r\n",
+             esc_tag);
+    safesprintf(printbuf, totallen, offset, tmpbuf);
+
+    for (tmp = taskhead->next; tmp != taskend; tmp = tmp->next)
+    {
+        task = krhino_list_entry(tmp, ktask_t, task_stats_item);
+        const name_t *task_name;
+        rst = krhino_task_stack_min_free(task, &free_size);
+
+        if (rst != RHINO_SUCCESS)
+        {
+            free_size = 0;
+        }
+
+#if (RHINO_CONFIG_TASK_SCHED_STATS > 0)
+        time_total = (sys_time_t)(task->task_time_total_run / 20);
+#endif
+
+        if (task->task_name != NULL)
+        {
+            task_name = task->task_name;
+        }
+        else
+        {
+            task_name = "anonym";
+        }
+
+        if (candidate == task)
+        {
+            yes = 'Y';
+        }
+        else
+        {
+            yes = 'N';
+        }
+
+        taskstate = task->task_state >= sizeof(cpu_stat) / sizeof(cpu_stat[0]) ? 0 : task->task_state;
+
+#ifndef HAVE_NOT_ADVANCED_FORMATE
+        snprintf(tmpbuf, 255, "%s%-19.18s%-9s%-5d%-10d%-12zu%-9llu%-11c\r\n",
+                 esc_tag, task_name, cpu_stat[taskstate], task->prio,
+                 task->stack_size, free_size, (unsigned long long)time_total, yes);
+#else
+        char name_cut[19];
+        /* if not support %-N.Ms,cut it manually */
+        if (strlen(task_name) > 18)
+        {
+            memset(name_cut, 0, sizeof(name_cut));
+            memcpy(name_cut, task->task_name, 18);
+            task_name = name_cut;
+        }
+
+        snprintf(tmpbuf, 255, "%s%-19s%-9s%-5d%-10d%-12u%-9u%-11c\r\n",
+                 esc_tag, task_name, cpu_stat[taskstate], task->prio,
+                 task->stack_size, free_size, (unsigned int)time_total, yes);
+#endif
+        safesprintf(printbuf, totallen, offset, tmpbuf);
+
+#if 0
+        /* for chip not support stack frame interface,do nothing*/
+        if (detail == true && task != krhino_cur_task_get() && soc_get_first_frame_info &&
+            soc_get_subs_frame_info) {
+            depth = RHINO_BACKTRACE_DEPTH;
+            snprintf(tmpbuf, 255, "%sTask %s Call Stack Dump:\r\n", esc_tag, task_name);
+            safesprintf(printbuf, totallen, offset, tmpbuf);
+            c_frame = (size_t)task->task_stack;
+            soc_get_first_frame_info(c_frame, &n_frame, &pc);
+
+            for (; (n_frame != 0) && (pc != 0) && (depth >= 0); --depth) {
+
+                snprintf(tmpbuf, 255, "%sPC:0x%-12xSP:0x%-12x\r\n", esc_tag, c_frame, pc);
+                safesprintf(printbuf, totallen, offset, tmpbuf);
+                c_frame = n_frame;
+                soc_get_subs_frame_info(c_frame, &n_frame, &pc);
+            }
+        }
+#endif
+    }
+
+    snprintf(tmpbuf, 255,
+             "%s------------------------------------------------------------------------\r\n",
+             esc_tag);
+    safesprintf(printbuf, totallen, offset, tmpbuf);
+    krhino_sched_enable();
+
+    csp_printf("%s", printbuf);
+    aos_free(printbuf);
+    return RHINO_SUCCESS;
+}
+
+#if (RHINO_CONFIG_CPU_USAGE_STATS > 0) || (RHINO_CONFIG_DISABLE_SCHED_STATS > 0) || (RHINO_CONFIG_DISABLE_INTRPT_STATS > 0)
+static uint32_t dumpsys_info_func(char *buf, uint32_t len)
+{
+    int16_t plen = 0;
+
+    plen += sprintf(buf + plen, "%s---------------------------------------------\r\n", esc_tag);
+#if (RHINO_CONFIG_CPU_USAGE_STATS > 0)
+    plen += sprintf(buf + plen, "%sCPU usage :%-10d     \r\n", esc_tag,
+                    g_cpu_usage / 100);
+#endif
+
+#if (RHINO_CONFIG_DISABLE_SCHED_STATS > 0)
+    plen += sprintf(buf + plen, "%sMax sched disable time  :%-10d\r\n", esc_tag,
+                    g_sched_disable_max_time);
+#else
+    plen += sprintf(buf + plen, "%sMax sched disable time  :%-10d\r\n", esc_tag, 0);
+#endif
+
+#if (RHINO_CONFIG_DISABLE_INTRPT_STATS > 0)
+    plen += sprintf(buf + plen, "%sMax intrpt disable time :%-10d\r\n", esc_tag,
+                    g_intrpt_disable_max_time);
+#else
+    plen += sprintf(buf + plen, "%sMax intrpt disable time :%-10d\r\n", esc_tag, 0);
+#endif
+
+    plen += sprintf(buf + plen, "%s---------------------------------------------\r\n", esc_tag);
+
+    return RHINO_SUCCESS;
+}
+#endif
+
+#if (RHINO_CONFIG_MM_LEAKCHECK > 0)
+
+uint32_t dumpsys_mm_leak_func(char *buf, uint32_t len)
+{
+    dump_mmleak();
+    return RHINO_SUCCESS;
+}
+
+uint8_t mm_leak_timer_cb(void *timer, void *arg)
+{
+    dumpsys_mm_info_func(0);
+    return 0;
+}
+
+uint32_t dumpsys_mm_leak_check_func(char *pcWriteBuffer, int xWriteBufferLen,
+                                    int argc, char **argv)
+{
+    static uint32_t run_flag = 0;
+    sys_time_t round_sec = MM_LEAK_CHECK_ROUND_SCOND;
+
+    if (argc > 2 && 0 == strcmp(argv[2], "start"))
+    {
+        if (0 == run_flag)
+        {
+            if (argc > 3 && NULL != argv[3])
+            {
+                round_sec = atoi(argv[3]) * 1000;
+            }
+
+            krhino_timer_create(&g_mm_leak_check_timer, "mm_leak_check_timer",
+                                (timer_cb_t)mm_leak_timer_cb,
+                                10, krhino_ms_to_ticks(round_sec), NULL, 0);
+        }
+        else
+        {
+            if (NULL != argv[3])
+            {
+                round_sec = atoi(argv[3]) * 1000;
+
+                if (1 == run_flag)
+                {
+                    krhino_timer_stop(&g_mm_leak_check_timer);
+                }
+
+                krhino_timer_change(&g_mm_leak_check_timer, 10, krhino_ms_to_ticks(round_sec));
+            }
+        }
+
+        run_flag = 1;
+        krhino_timer_start(&g_mm_leak_check_timer);
+    }
+
+    if (argc > 2 && 0 == strcmp(argv[2], "stop"))
+    {
+        krhino_timer_stop(&g_mm_leak_check_timer);
+        run_flag = 2;
+    }
+
+    return RHINO_SUCCESS;
+}
+#endif
+
+uint32_t dumpsys_func(char *pcWriteBuffer, int xWriteBufferLen, int argc,
+                      char **argv)
+{
+    uint32_t ret;
+
+    if (argc >= 2 && 0 == strcmp(argv[1], "task"))
+    {
+        if (argc == 3 && (0 == strcmp(argv[2], "detail")))
+        {
+            ret = dumpsys_task_func(pcWriteBuffer, xWriteBufferLen, true);
+        }
+        else
+        {
+            ret = dumpsys_task_func(pcWriteBuffer, xWriteBufferLen, false);
+        }
+
+        return ret;
+    }
+#ifndef CSP_LINUXHOST
+    else if (argc >= 2 && 0 == strcmp(argv[1], "task_stack"))
+    {
+        if (argc == 3)
+        {
+            ret = dump_task_stack_byname(argv[2]);
+        }
+        else
+        {
+            ret = dump_task_stack_byname((char *)krhino_cur_task_get()->task_name);
+        }
+
+        return ret;
+    }
+#endif
+
+#if (RHINO_CONFIG_CPU_USAGE_STATS > 0) || (RHINO_CONFIG_DISABLE_SCHED_STATS > 0) || (RHINO_CONFIG_DISABLE_INTRPT_STATS > 0)
+    else if (argc == 2 && 0 == strcmp(argv[1], "info"))
+    {
+        ret = dumpsys_info_func(pcWriteBuffer, xWriteBufferLen);
+        return ret;
+    }
+#endif
+
+#if (RHINO_CONFIG_MM_DEBUG > 0)
+    else if (argc == 2 && 0 == strcmp(argv[1], "mm_info"))
+    {
+        ret = dumpsys_mm_info_func(0);
+        return ret;
+    }
+#endif
+
+#if (RHINO_CONFIG_MM_LEAKCHECK > 0)
+    else if (argc == 2 && 0 == strcmp(argv[1], "mm_leak"))
+    {
+        ret = dumpsys_mm_leak_func(NULL, 0);
+        return ret;
+    }
+    else if (argc > 2 && 0 == strcmp(argv[1], "mm_monitor"))
+    {
+        ret = dumpsys_mm_leak_check_func(pcWriteBuffer, xWriteBufferLen, argc, argv);
+        return ret;
+    }
+#endif
+    else
+    {
+        int len = 0;
+        len += snprintf(pcWriteBuffer + len, xWriteBufferLen - len,
+                        "%sdumpsys help:\r\n", esc_tag);
+        len += snprintf(pcWriteBuffer + len, xWriteBufferLen - len,
+                        "%s\tdumpsys task         : show the task info.\r\n", esc_tag);
+#ifndef CSP_LINUXHOST
+        len += snprintf(pcWriteBuffer + len, xWriteBufferLen - len,
+                        "%s\tdumpsys task_stack   : show the task stack info.\r\n", esc_tag);
+#endif
+        len += snprintf(pcWriteBuffer + len, xWriteBufferLen - len,
+                        "%s\tdumpsys mm_info      : show the memory has alloced.\r\n", esc_tag);
+#if (RHINO_CONFIG_MM_LEAKCHECK > 0)
+        len += snprintf(pcWriteBuffer + len, xWriteBufferLen - len,
+                        "%s\tdumpsys mm_leak      : show the memory maybe leak.\r\n", esc_tag);
+        len += snprintf(pcWriteBuffer + len, xWriteBufferLen - len,
+                        "%s\tdumpsys mm_monitor   : [start/stop] [round time] fire a timer"
+                        "to monitor mm, default 10s.\r\n",
+                        esc_tag);
+#endif
+#if (RHINO_CONFIG_CPU_USAGE_STATS > 0)
+        len += snprintf(pcWriteBuffer + len, xWriteBufferLen - len,
+                        "%s\tdumpsys info         : show the system info\r\n", esc_tag);
+#endif
+        return RHINO_SUCCESS;
+    }
+}
+
+int dump_task_stack(ktask_t *task)
+{
+    uint32_t offset = 0;
+    kstat_t rst = RHINO_SUCCESS;
+    void *cur, *end;
+    int i = 0;
+    int *p;
+    char tmp[256] = {0};
+
+    char *printbuf = NULL;
+    char tmpbuf[256] = {0};
+    int bufoffset = 0;
+    int totallen = 2048;
+
+    printbuf = aos_malloc(totallen);
+    if (printbuf == NULL)
+    {
+        return RHINO_NO_MEM;
+    }
+    memset(printbuf, 0, totallen);
+    krhino_sched_disable();
+
+    end = task->task_stack_base + task->stack_size;
+
+    rst = krhino_task_stack_cur_free(task, &offset);
+    if (rst == RHINO_SUCCESS)
+    {
+        cur = task->task_stack_base + task->stack_size - offset;
+    }
+    else
+    {
+        k_err_proc(RHINO_SYS_SP_ERR);
+        aos_free(printbuf);
+        krhino_sched_enable();
+        return 1;
+    }
+    p = (int *)cur;
+    while (p < (int *)end)
+    {
+        if (i % 4 == 0)
+        {
+            sprintf(tmp, "%s\r\n%08x:", esc_tag, (uint32_t)p);
+            safesprintf(printbuf, totallen, bufoffset, tmp);
+        }
+        sprintf(tmp, "%s%08x ", esc_tag, *p);
+        safesprintf(printbuf, totallen, bufoffset, tmp);
+        i++;
+        p++;
+    }
+    snprintf(tmpbuf, 255, "%s\r\n-----------------end----------------\r\n\r\n", esc_tag);
+    safesprintf(printbuf, totallen, offset, tmpbuf);
+    krhino_sched_enable();
+
+    csp_printf("%s", printbuf);
+    aos_free(printbuf);
+    return 0;
+}
+
+int dump_task_stack_byname(char *taskname)
+{
+    klist_t *taskhead = &g_kobj_list.task_head;
+    klist_t *taskend = taskhead;
+    klist_t *tmp;
+    ktask_t *task;
+    int printall = 0;
+
+    if (strcmp(taskname, "all") == 0)
+    {
+        printall = 1;
+    }
+
+    for (tmp = taskhead->next; tmp != taskend; tmp = tmp->next)
+    {
+        task = krhino_list_entry(tmp, ktask_t, task_stats_item);
+        if (printall == 1 || strcmp(taskname, task->task_name) == 0)
+        {
+            csp_printf("%s------task %s stack -------", esc_tag, task->task_name);
+            dump_task_stack(task);
+        }
+    }
+
+    return 0;
+}
+
+static void task_cmd(char *buf, int len, int argc, char **argv)
+{
+    dumpsys_task_func(NULL, 0, 1);
+}
+
+static void dumpsys_cmd(char *buf, int len, int argc, char **argv)
+{
+    dumpsys_func(buf, len, argc, argv);
+}
+
+struct cli_command dumpsys_cli_cmd[] = {
+    {"tasklist", "list all thread info", task_cmd},
+    {"dumpsys", "dump system info", dumpsys_cmd},
+};
+
+void dumpsys_cli_init(void)
+{
+    aos_cli_register_commands(&dumpsys_cli_cmd[0], sizeof(dumpsys_cli_cmd) / sizeof(struct cli_command));
+}
+
+#endif

Living_SDK/tools/cli/dumpsys.h

@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2015-2017 Alibaba Group Holding Limited
+ */
+
+#ifndef DUMPSYS_H
+#define DUMPSYS_H
+
+uint32_t dumpsys_task_func(char *buf, uint32_t len, int detail);
+uint32_t dumpsys_func(char *buf, int len, int argc, char **argv);
+
+#endif
+

Living_SDK/tools/cli/ucube.py

@@ -0,0 +1,13 @@
+src     = Split('''
+        cli.c 
+        dumpsys.c
+''')
+component = aos_component('cli', src)
+
+component.add_comp_deps('kernel/hal')
+
+component.add_global_macros('HAVE_NOT_ADVANCED_FORMATE')
+component.add_global_macros('CONFIG_AOS_CLI')
+
+
+component.add_global_includes('include')