chinky/rtt-f030
chinky/rtt-f030
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[finsh] Fix object name issue in list_* cmd.

Browse Source
This commit is contained in:
Bernard Xiong 2016-06-13 13:29:18 +08:00
parent 4d93c31cce
commit 45c7f03035
1 changed files with 113 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

200
components/finsh/cmd.c
View File

@ -82,52 +82,47 @@ MSH_CMD_EXPORT(version, show RT-Thread version information);
extern struct rt_object_information rt_object_container[];
static int object_name_maxlen(struct rt_list_node *list)
{
struct rt_list_node *node;
struct rt_object *object = NULL;
int max_length = 0, length;
rt_enter_critical();
for (node = list->next; node != list; node = node->next)
{
object = rt_list_entry(node, struct rt_object, list);
length = rt_strlen(object->name);
if (length > max_length) max_length = length;
}
rt_exit_critical();
if (max_length > RT_NAME_MAX || max_length == 0) max_length = RT_NAME_MAX;
return max_length;
}
rt_inline void object_split(int len)
{
while (len--) rt_kprintf("-");
}
static long _list_thread(struct rt_list_node *list)
{
int maxlen;
rt_uint8_t *ptr;
struct rt_thread *thread;
struct rt_list_node *node;
rt_uint8_t *ptr, cur_max_name_len = 0, cur_thread_name_len;
char thread_header[RT_NAME_MAX], thread_split[RT_NAME_MAX];
const char * thread_str = "thread";
rt_size_t i, thread_str_len = rt_strlen(thread_str), thread_str_index;
/* calculate the maximum thread name length */
for (node = list->next; node != list; node = node->next) {
thread = rt_list_entry(node, struct rt_thread, list);
cur_thread_name_len = rt_strlen(thread->name);
if(cur_max_name_len < cur_thread_name_len) {
cur_max_name_len = cur_thread_name_len;
}
}
maxlen = object_name_maxlen(list);
if (cur_max_name_len < thread_str_len) {
cur_max_name_len = thread_str_len;
}
/* calculate the "thread" string in header index */
thread_str_index = (cur_max_name_len - thread_str_len) / 2;
for (i = 0; i < cur_max_name_len; i ++) {
thread_split[i] = '-';
if (thread_str_len < cur_max_name_len) {
if (i < thread_str_index) {
thread_header[i] = ' ';
thread_header[cur_max_name_len - i - 1] = ' ';
} else if (i < thread_str_index + thread_str_len) {
thread_header[i] = thread_str[i - thread_str_index];
} else {
thread_header[i] = ' ';
}
}
}
thread_header[cur_max_name_len] = '\0';
thread_split[cur_max_name_len] = '\0';
rt_kprintf("%s pri status sp stack size max used left tick error\n", thread_header);
rt_kprintf("%s -- ------- ---------- ---------- --- ---------- ---\n", thread_split);
rt_kprintf("%-*.s pri status sp stack size max used left tick error\n", maxlen, "thread"); object_split(maxlen);
rt_kprintf( " -- ------- ---------- ---------- ------ ---------- ---\n");
for (node = list->next; node != list; node = node->next)
{
thread = rt_list_entry(node, struct rt_thread, list);
rt_kprintf("%-*.*s %02d ", cur_max_name_len, cur_max_name_len, thread->name, thread->current_priority);
rt_kprintf("%-*.*s %02d ", maxlen, RT_NAME_MAX, thread->name, thread->current_priority);
if (thread->stat == RT_THREAD_READY) rt_kprintf(" ready ");
else if (thread->stat == RT_THREAD_SUSPEND) rt_kprintf(" suspend");
@ -174,18 +169,22 @@ static void show_wait_queue(struct rt_list_node *list)
#ifdef RT_USING_SEMAPHORE
static long _list_sem(struct rt_list_node *list)
{
int maxlen;
struct rt_semaphore *sem;
struct rt_list_node *node;
rt_kprintf("semaphore v suspend thread\n");
rt_kprintf("-------- --- --------------\n");
maxlen = object_name_maxlen(list);
if (maxlen < 9) maxlen = 9;
rt_kprintf("%-*.s v suspend thread\n", maxlen, "semaphore"); object_split(maxlen);
rt_kprintf( " --- --------------\n");
for (node = list->next; node != list; node = node->next)
{
sem = (struct rt_semaphore *)(rt_list_entry(node, struct rt_object, list));
if (!rt_list_isempty(&sem->parent.suspend_thread))
{
rt_kprintf("%-8.*s %03d %d:",
RT_NAME_MAX,
rt_kprintf("%-*.*s %03d %d:",
maxlen, RT_NAME_MAX,
sem->parent.parent.name,
sem->value,
rt_list_len(&sem->parent.suspend_thread));
@ -194,8 +193,8 @@ static long _list_sem(struct rt_list_node *list)
}
else
{
rt_kprintf("%-8.*s %03d %d\n",
RT_NAME_MAX,
rt_kprintf("%-*.*s %03d %d\n",
maxlen, RT_NAME_MAX,
sem->parent.parent.name,
sem->value,
rt_list_len(&sem->parent.suspend_thread));
@ -216,18 +215,21 @@ MSH_CMD_EXPORT(list_sem, list semaphore in system);
#ifdef RT_USING_EVENT
static long _list_event(struct rt_list_node *list)
{
int maxlen;
struct rt_event *e;
struct rt_list_node *node;
rt_kprintf("event set suspend thread\n");
rt_kprintf("-------- ---------- --------------\n");
maxlen = object_name_maxlen(list);
rt_kprintf("%-*.s set suspend thread\n", maxlen, "event"); object_split(maxlen);
rt_kprintf(" ---------- --------------\n");
for (node = list->next; node != list; node = node->next)
{
e = (struct rt_event *)(rt_list_entry(node, struct rt_object, list));
if (!rt_list_isempty(&e->parent.suspend_thread))
{
rt_kprintf("%-8.*s 0x%08x %03d:",
RT_NAME_MAX,
rt_kprintf("%-*.*s 0x%08x %03d:",
maxlen, RT_NAME_MAX,
e->parent.parent.name,
e->set,
rt_list_len(&e->parent.suspend_thread));
@ -236,8 +238,8 @@ static long _list_event(struct rt_list_node *list)
}
else
{
rt_kprintf("%-8.*s 0x%08x 0\n",
RT_NAME_MAX, e->parent.parent.name, e->set);
rt_kprintf("%-*.*s 0x%08x 0\n",
maxlen, RT_NAME_MAX, e->parent.parent.name, e->set);
}
}
@ -255,16 +257,18 @@ MSH_CMD_EXPORT(list_event, list event in system);
#ifdef RT_USING_MUTEX
static long _list_mutex(struct rt_list_node *list)
{
int maxlen;
struct rt_mutex *m;
struct rt_list_node *node;
rt_kprintf("mutex owner hold suspend thread\n");
rt_kprintf("-------- -------- ---- --------------\n");
maxlen = object_name_maxlen(list);
rt_kprintf("%-*.s owner hold suspend thread\n", maxlen, "mutex"); object_split(maxlen);
rt_kprintf( " -------- ---- --------------\n");
for (node = list->next; node != list; node = node->next)
{
m = (struct rt_mutex *)(rt_list_entry(node, struct rt_object, list));
rt_kprintf("%-8.*s %-8.*s %04d %d\n",
RT_NAME_MAX,
rt_kprintf("%-*.*s %-8.*s %04d %d\n",
maxlen, RT_NAME_MAX,
m->parent.parent.name,
RT_NAME_MAX,
m->owner->name,
@ -286,18 +290,21 @@ MSH_CMD_EXPORT(list_mutex, list mutex in system);
#ifdef RT_USING_MAILBOX
static long _list_mailbox(struct rt_list_node *list)
{
int maxlen;
struct rt_mailbox *m;
struct rt_list_node *node;
rt_kprintf("mailbox entry size suspend thread\n");
rt_kprintf("-------- ---- ---- --------------\n");
maxlen = object_name_maxlen(list);
rt_kprintf("%-*.s entry size suspend thread\n", maxlen, "mailbox"); object_split(maxlen);
rt_kprintf( " ---- ---- --------------\n");
for (node = list->next; node != list; node = node->next)
{
m = (struct rt_mailbox *)(rt_list_entry(node, struct rt_object, list));
if (!rt_list_isempty(&m->parent.suspend_thread))
{
rt_kprintf("%-8.*s %04d %04d %d:",
RT_NAME_MAX,
rt_kprintf("%-*.*s %04d %04d %d:",
maxlen, RT_NAME_MAX,
m->parent.parent.name,
m->entry,
m->size,
@ -307,8 +314,8 @@ static long _list_mailbox(struct rt_list_node *list)
}
else
{
rt_kprintf("%-8.*s %04d %04d %d\n",
RT_NAME_MAX,
rt_kprintf("%-*.*s %04d %04d %d\n",
maxlen, RT_NAME_MAX,
m->parent.parent.name,
m->entry,
m->size,
@ -330,18 +337,21 @@ MSH_CMD_EXPORT(list_mailbox, list mail box in system);
#ifdef RT_USING_MESSAGEQUEUE
static long _list_msgqueue(struct rt_list_node *list)
{
int maxlen;
struct rt_messagequeue *m;
struct rt_list_node *node;
rt_kprintf("msgqueue entry suspend thread\n");
rt_kprintf("-------- ---- --------------\n");
maxlen = object_name_maxlen(list);
rt_kprintf("%-*.s entry suspend thread\n", maxlen, "msgqueue"); object_split(maxlen);
rt_kprintf( " ---- --------------\n");
for (node = list->next; node != list; node = node->next)
{
m = (struct rt_messagequeue *)(rt_list_entry(node, struct rt_object, list));
if (!rt_list_isempty(&m->parent.suspend_thread))
{
rt_kprintf("%-8.*s %04d %d:",
RT_NAME_MAX,
rt_kprintf("%-*.*s %04d %d:",
maxlen, RT_NAME_MAX,
m->parent.parent.name,
m->entry,
rt_list_len(&m->parent.suspend_thread));
@ -350,8 +360,8 @@ static long _list_msgqueue(struct rt_list_node *list)
}
else
{
rt_kprintf("%-8.*s %04d %d\n",
RT_NAME_MAX,
rt_kprintf("%-*.*s %04d %d\n",
maxlen, RT_NAME_MAX,
m->parent.parent.name,
m->entry,
rt_list_len(&m->parent.suspend_thread));
@ -372,17 +382,20 @@ MSH_CMD_EXPORT(list_msgqueue, list message queue in system);
#ifdef RT_USING_MEMHEAP
static long _list_memheap(struct rt_list_node *list)
{
int maxlen;
struct rt_memheap *mh;
struct rt_list_node *node;
rt_kprintf("memheap pool size max used size available size\n");
rt_kprintf("-------- ---------- ------------- --------------\n");
maxlen = object_name_maxlen(list);
rt_kprintf("%-*.s pool size max used size available size\n", maxlen, "memheap"); object_split(maxlen);
rt_kprintf( " ---------- ------------- --------------\n");
for (node = list->next; node != list; node = node->next)
{
mh = (struct rt_memheap *)rt_list_entry(node, struct rt_object, list);
rt_kprintf("%-8.*s %-010d %-013d %-05d\n",
RT_NAME_MAX,
rt_kprintf("%-*.*s %-010d %-013d %-05d\n",
maxlen, RT_NAME_MAX,
mh->parent.name,
mh->pool_size,
mh->max_used_size,
@ -403,18 +416,21 @@ MSH_CMD_EXPORT(list_memheap, list memory heap in system);
#ifdef RT_USING_MEMPOOL
static long _list_mempool(struct rt_list_node *list)
{
int maxlen;
struct rt_mempool *mp;
struct rt_list_node *node;
rt_kprintf("mempool block total free suspend thread\n");
rt_kprintf("-------- ---- ---- ---- --------------\n");
maxlen = object_name_maxlen(list);
rt_kprintf("%-*.s block total free suspend thread\n", maxlen, "mempool"); object_split(maxlen);
rt_kprintf( " ---- ---- ---- --------------\n");
for (node = list->next; node != list; node = node->next)
{
mp = (struct rt_mempool *)rt_list_entry(node, struct rt_object, list);
if (mp->suspend_thread_count > 0)
{
rt_kprintf("%-8.*s %04d %04d %04d %d:",
RT_NAME_MAX,
rt_kprintf("%-*.*s %04d %04d %04d %d:",
maxlen, RT_NAME_MAX,
mp->parent.name,
mp->block_size,
mp->block_total_count,
@ -425,8 +441,8 @@ static long _list_mempool(struct rt_list_node *list)
}
else
{
rt_kprintf("%-8.*s %04d %04d %04d %d\n",
RT_NAME_MAX,
rt_kprintf("%-*.*s %04d %04d %04d %d\n",
maxlen, RT_NAME_MAX,
mp->parent.name,
mp->block_size,
mp->block_total_count,
@ -448,16 +464,19 @@ MSH_CMD_EXPORT(list_mempool, list memory pool in system);
static long _list_timer(struct rt_list_node *list)
{
int maxlen;
struct rt_timer *timer;
struct rt_list_node *node;
rt_kprintf("timer periodic timeout flag\n");
rt_kprintf("-------- ---------- ---------- -----------\n");
maxlen = object_name_maxlen(list);
rt_kprintf("%-*.s periodic timeout flag\n", maxlen, "timer"); object_split(maxlen);
rt_kprintf( " ---------- ---------- -----------\n");
for (node = list->next; node != list; node = node->next)
{
timer = (struct rt_timer *)(rt_list_entry(node, struct rt_object, list));
rt_kprintf("%-8.*s 0x%08x 0x%08x ",
RT_NAME_MAX,
rt_kprintf("%-*.*s 0x%08x 0x%08x ",
maxlen, RT_NAME_MAX,
timer->parent.name,
timer->init_tick,
timer->timeout_tick);
@ -482,6 +501,7 @@ MSH_CMD_EXPORT(list_timer, list timer in system);
#ifdef RT_USING_DEVICE
static long _list_device(struct rt_list_node *list)
{
int maxlen;
struct rt_device *device;
struct rt_list_node *node;
char *const device_type_str[] =
@ -508,13 +528,15 @@ static long _list_device(struct rt_list_node *list)
"Unknown"
};
rt_kprintf("device type ref count\n");
rt_kprintf("-------- -------------------- ----------\n");
maxlen = object_name_maxlen(list);
rt_kprintf("%-*.s type ref count\n", maxlen, "device"); object_split(maxlen);
rt_kprintf( " -------------------- ----------\n");
for (node = list->next; node != list; node = node->next)
{
device = (struct rt_device *)(rt_list_entry(node, struct rt_object, list));
rt_kprintf("%-8.*s %-20s %-8d\n",
RT_NAME_MAX,
rt_kprintf("%-*.*s %-20s %-8d\n",
maxlen, RT_NAME_MAX,
device->parent.name,
(device->type <= RT_Device_Class_Unknown) ?
device_type_str[device->type] :
@ -538,18 +560,22 @@ MSH_CMD_EXPORT(list_device, list device in system);
int list_module(void)
{
int maxlen;
struct rt_module *module;
struct rt_list_node *list, *node;
list = &rt_object_container[RT_Object_Class_Module].object_list;
rt_kprintf("module name ref address \n");
rt_kprintf("------------ -------- ------------\n");
maxlen = object_name_maxlen(list);
rt_kprintf("%-*.s ref address \n", maxlen, "module"); object_split(maxlen);
rt_kprintf( " -------- ------------\n");
for (node = list->next; node != list; node = node->next)
{
module = (struct rt_module *)(rt_list_entry(node, struct rt_object, list));
rt_kprintf("%-16.*s %-04d 0x%08x\n",
RT_NAME_MAX, module->parent.name, module->nref, module->module_space);
rt_kprintf("%-*.*s %-04d 0x%08x\n",
maxlen, RT_NAME_MAX,
module->parent.name, module->nref, module->module_space);
}
return 0;