cmd.c 35 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133
  1. /*
  2. * Copyright (c) 2006-2022, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2006-04-30 Bernard first implementation
  9. * 2006-05-04 Bernard add list_thread,
  10. * list_sem,
  11. * list_timer
  12. * 2006-05-20 Bernard add list_mutex,
  13. * list_mailbox,
  14. * list_msgqueue,
  15. * list_event,
  16. * list_fevent,
  17. * list_mempool
  18. * 2006-06-03 Bernard display stack information in list_thread
  19. * 2006-08-10 Bernard change version to invoke rt_show_version
  20. * 2008-09-10 Bernard update the list function for finsh syscall
  21. * list and sysvar list
  22. * 2009-05-30 Bernard add list_device
  23. * 2010-04-21 yi.qiu add list_module
  24. * 2012-04-29 goprife improve the command line auto-complete feature.
  25. * 2012-06-02 lgnq add list_memheap
  26. * 2012-10-22 Bernard add MS VC++ patch.
  27. * 2016-06-02 armink beautify the list_thread command
  28. * 2018-11-22 Jesven list_thread add smp support
  29. * 2018-12-27 Jesven Fix the problem that disable interrupt too long in list_thread
  30. * Provide protection for the "first layer of objects" when list_*
  31. * 2020-04-07 chenhui add clear
  32. * 2022-07-02 Stanley Lwin add list command
  33. * 2023-09-15 xqyjlj perf rt_hw_interrupt_disable/enable
  34. */
  35. #include <rthw.h>
  36. #include <rtthread.h>
  37. #include <string.h>
  38. #ifdef RT_USING_FINSH
  39. #include <finsh.h>
  40. #define LIST_DFS_OPT_ID 0x100
  41. #define LIST_FIND_OBJ_NR 8
  42. static long clear(void)
  43. {
  44. rt_kprintf("\x1b[2J\x1b[H");
  45. return 0;
  46. }
  47. MSH_CMD_EXPORT(clear, clear the terminal screen);
  48. extern void rt_show_version(void);
  49. long version(void)
  50. {
  51. rt_show_version();
  52. return 0;
  53. }
  54. MSH_CMD_EXPORT(version, show RT-Thread version information);
  55. rt_inline void object_split(int len)
  56. {
  57. while (len--) rt_kprintf("-");
  58. }
  59. typedef struct
  60. {
  61. rt_list_t *list;
  62. rt_list_t **array;
  63. rt_uint8_t type;
  64. int nr; /* input: max nr, can't be 0 */
  65. int nr_out; /* out: got nr */
  66. } list_get_next_t;
  67. static void list_find_init(list_get_next_t *p, rt_uint8_t type, rt_list_t **array, int nr)
  68. {
  69. struct rt_object_information *info;
  70. rt_list_t *list;
  71. info = rt_object_get_information((enum rt_object_class_type)type);
  72. list = &info->object_list;
  73. p->list = list;
  74. p->type = type;
  75. p->array = array;
  76. p->nr = nr;
  77. p->nr_out = 0;
  78. }
  79. static rt_list_t *list_get_next(rt_list_t *current, list_get_next_t *arg)
  80. {
  81. int first_flag = 0;
  82. rt_base_t level;
  83. rt_list_t *node, *list;
  84. rt_list_t **array;
  85. struct rt_object_information *info;
  86. int nr;
  87. arg->nr_out = 0;
  88. if (!arg->nr || !arg->type)
  89. {
  90. return (rt_list_t *)RT_NULL;
  91. }
  92. list = arg->list;
  93. info = rt_list_entry(list, struct rt_object_information, object_list);
  94. if (!current) /* find first */
  95. {
  96. node = list;
  97. first_flag = 1;
  98. }
  99. else
  100. {
  101. node = current;
  102. }
  103. level = rt_spin_lock_irqsave(&info->spinlock);
  104. if (!first_flag)
  105. {
  106. struct rt_object *obj;
  107. /* The node in the list? */
  108. obj = rt_list_entry(node, struct rt_object, list);
  109. if ((obj->type & ~RT_Object_Class_Static) != arg->type)
  110. {
  111. rt_spin_unlock_irqrestore(&info->spinlock, level);
  112. return (rt_list_t *)RT_NULL;
  113. }
  114. }
  115. nr = 0;
  116. array = arg->array;
  117. while (1)
  118. {
  119. node = node->next;
  120. if (node == list)
  121. {
  122. node = (rt_list_t *)RT_NULL;
  123. break;
  124. }
  125. nr++;
  126. *array++ = node;
  127. if (nr == arg->nr)
  128. {
  129. break;
  130. }
  131. }
  132. rt_spin_unlock_irqrestore(&info->spinlock, level);
  133. arg->nr_out = nr;
  134. return node;
  135. }
  136. long list_thread(void)
  137. {
  138. rt_base_t level;
  139. list_get_next_t find_arg;
  140. struct rt_object_information *info;
  141. rt_list_t *obj_list[LIST_FIND_OBJ_NR];
  142. rt_list_t *next = (rt_list_t *)RT_NULL;
  143. const char *item_title = "thread";
  144. const size_t tcb_strlen = sizeof(void *) * 2 + 2;
  145. int maxlen;
  146. list_find_init(&find_arg, RT_Object_Class_Thread, obj_list, sizeof(obj_list) / sizeof(obj_list[0]));
  147. info = rt_list_entry(find_arg.list, struct rt_object_information, object_list);
  148. maxlen = RT_NAME_MAX;
  149. #ifdef RT_USING_SMP
  150. rt_kprintf("%-*.*s cpu bind pri status sp stack size max used left tick error tcb addr\n", maxlen, maxlen, item_title);
  151. object_split(maxlen);
  152. rt_kprintf(" --- ---- --- ------- ---------- ---------- ------ ---------- -------");
  153. rt_kprintf(" ");
  154. object_split(tcb_strlen);
  155. rt_kprintf("\n");
  156. #else
  157. rt_kprintf("%-*.*s pri status sp stack size max used left tick error tcb addr\n", maxlen, maxlen, item_title);
  158. object_split(maxlen);
  159. rt_kprintf(" --- ------- ---------- ---------- ------ ---------- -------");
  160. rt_kprintf(" ");
  161. object_split(tcb_strlen);
  162. rt_kprintf("\n");
  163. #endif /*RT_USING_SMP*/
  164. do
  165. {
  166. next = list_get_next(next, &find_arg);
  167. {
  168. int i;
  169. for (i = 0; i < find_arg.nr_out; i++)
  170. {
  171. struct rt_object *obj;
  172. struct rt_thread thread_info, *thread;
  173. obj = rt_list_entry(obj_list[i], struct rt_object, list);
  174. level = rt_spin_lock_irqsave(&info->spinlock);
  175. if ((obj->type & ~RT_Object_Class_Static) != find_arg.type)
  176. {
  177. rt_spin_unlock_irqrestore(&info->spinlock, level);
  178. continue;
  179. }
  180. /* copy info */
  181. rt_memcpy(&thread_info, obj, sizeof thread_info);
  182. rt_spin_unlock_irqrestore(&info->spinlock, level);
  183. thread = (struct rt_thread *)obj;
  184. {
  185. rt_uint8_t stat;
  186. rt_uint8_t *ptr;
  187. #ifdef RT_USING_SMP
  188. if (thread->oncpu != RT_CPU_DETACHED)
  189. rt_kprintf("%-*.*s %3d %3d %4d ", maxlen, RT_NAME_MAX, thread->parent.name, thread->oncpu, thread->bind_cpu, thread->current_priority);
  190. else
  191. rt_kprintf("%-*.*s N/A %3d %4d ", maxlen, RT_NAME_MAX, thread->parent.name, thread->bind_cpu, thread->current_priority);
  192. #else
  193. rt_kprintf("%-*.*s %3d ", maxlen, RT_NAME_MAX, thread->parent.name, thread->current_priority);
  194. #endif /*RT_USING_SMP*/
  195. stat = (thread->stat & RT_THREAD_STAT_MASK);
  196. if (stat == RT_THREAD_READY) rt_kprintf(" ready ");
  197. else if ((stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK) rt_kprintf(" suspend");
  198. else if (stat == RT_THREAD_INIT) rt_kprintf(" init ");
  199. else if (stat == RT_THREAD_CLOSE) rt_kprintf(" close ");
  200. else if (stat == RT_THREAD_RUNNING) rt_kprintf(" running");
  201. #if defined(ARCH_CPU_STACK_GROWS_UPWARD)
  202. ptr = (rt_uint8_t *)thread->stack_addr + thread->stack_size - 1;
  203. while (*ptr == '#')ptr --;
  204. rt_kprintf(" 0x%08x 0x%08x %02d%% 0x%08x %s %p\n",
  205. ((rt_ubase_t)thread->sp - (rt_ubase_t)thread->stack_addr),
  206. thread->stack_size,
  207. ((rt_ubase_t)ptr - (rt_ubase_t)thread->stack_addr) * 100 / thread->stack_size,
  208. thread->remaining_tick,
  209. rt_strerror(thread->error),
  210. thread);
  211. #else
  212. ptr = (rt_uint8_t *)thread->stack_addr;
  213. while (*ptr == '#') ptr ++;
  214. rt_kprintf(" 0x%08x 0x%08x %02d%% 0x%08x %s %p\n",
  215. thread->stack_size + ((rt_ubase_t)thread->stack_addr - (rt_ubase_t)thread->sp),
  216. thread->stack_size,
  217. (thread->stack_size - ((rt_ubase_t) ptr - (rt_ubase_t) thread->stack_addr)) * 100
  218. / thread->stack_size,
  219. thread->remaining_tick,
  220. rt_strerror(thread->error),
  221. thread);
  222. #endif
  223. }
  224. }
  225. }
  226. }
  227. while (next != (rt_list_t *)RT_NULL);
  228. return 0;
  229. }
  230. static void show_wait_queue(struct rt_list_node *list)
  231. {
  232. struct rt_thread *thread;
  233. struct rt_list_node *node;
  234. for (node = list->next; node != list; node = node->next)
  235. {
  236. thread = rt_list_entry(node, struct rt_thread, tlist);
  237. rt_kprintf("%.*s", RT_NAME_MAX, thread->parent.name);
  238. if (node->next != list)
  239. rt_kprintf("/");
  240. }
  241. }
  242. #ifdef RT_USING_SEMAPHORE
  243. long list_sem(void)
  244. {
  245. rt_base_t level;
  246. list_get_next_t find_arg;
  247. struct rt_object_information *info;
  248. rt_list_t *obj_list[LIST_FIND_OBJ_NR];
  249. rt_list_t *next = (rt_list_t *)RT_NULL;
  250. int maxlen;
  251. const char *item_title = "semaphore";
  252. list_find_init(&find_arg, RT_Object_Class_Semaphore, obj_list, sizeof(obj_list) / sizeof(obj_list[0]));
  253. info = rt_list_entry(find_arg.list, struct rt_object_information, object_list);
  254. maxlen = RT_NAME_MAX;
  255. rt_kprintf("%-*.*s v suspend thread\n", maxlen, maxlen, item_title);
  256. object_split(maxlen);
  257. rt_kprintf(" --- --------------\n");
  258. do
  259. {
  260. next = list_get_next(next, &find_arg);
  261. {
  262. int i;
  263. for (i = 0; i < find_arg.nr_out; i++)
  264. {
  265. struct rt_object *obj;
  266. struct rt_semaphore *sem;
  267. obj = rt_list_entry(obj_list[i], struct rt_object, list);
  268. level = rt_spin_lock_irqsave(&info->spinlock);
  269. if ((obj->type & ~RT_Object_Class_Static) != find_arg.type)
  270. {
  271. rt_spin_unlock_irqrestore(&info->spinlock, level);
  272. continue;
  273. }
  274. rt_spin_unlock_irqrestore(&info->spinlock, level);
  275. sem = (struct rt_semaphore *)obj;
  276. if (!rt_list_isempty(&sem->parent.suspend_thread))
  277. {
  278. rt_kprintf("%-*.*s %03d %d:",
  279. maxlen, RT_NAME_MAX,
  280. sem->parent.parent.name,
  281. sem->value,
  282. rt_list_len(&sem->parent.suspend_thread));
  283. show_wait_queue(&(sem->parent.suspend_thread));
  284. rt_kprintf("\n");
  285. }
  286. else
  287. {
  288. rt_kprintf("%-*.*s %03d %d\n",
  289. maxlen, RT_NAME_MAX,
  290. sem->parent.parent.name,
  291. sem->value,
  292. rt_list_len(&sem->parent.suspend_thread));
  293. }
  294. }
  295. }
  296. }
  297. while (next != (rt_list_t *)RT_NULL);
  298. return 0;
  299. }
  300. #endif /* RT_USING_SEMAPHORE */
  301. #ifdef RT_USING_EVENT
  302. long list_event(void)
  303. {
  304. rt_base_t level;
  305. list_get_next_t find_arg;
  306. struct rt_object_information *info;
  307. rt_list_t *obj_list[LIST_FIND_OBJ_NR];
  308. rt_list_t *next = (rt_list_t *)RT_NULL;
  309. int maxlen;
  310. const char *item_title = "event";
  311. list_find_init(&find_arg, RT_Object_Class_Event, obj_list, sizeof(obj_list) / sizeof(obj_list[0]));
  312. info = rt_list_entry(find_arg.list, struct rt_object_information, object_list);
  313. maxlen = RT_NAME_MAX;
  314. rt_kprintf("%-*.*s set suspend thread\n", maxlen, maxlen, item_title);
  315. object_split(maxlen);
  316. rt_kprintf(" ---------- --------------\n");
  317. do
  318. {
  319. next = list_get_next(next, &find_arg);
  320. {
  321. int i;
  322. for (i = 0; i < find_arg.nr_out; i++)
  323. {
  324. struct rt_object *obj;
  325. struct rt_event *e;
  326. obj = rt_list_entry(obj_list[i], struct rt_object, list);
  327. level = rt_spin_lock_irqsave(&info->spinlock);
  328. if ((obj->type & ~RT_Object_Class_Static) != find_arg.type)
  329. {
  330. rt_spin_unlock_irqrestore(&info->spinlock, level);
  331. continue;
  332. }
  333. rt_spin_unlock_irqrestore(&info->spinlock, level);
  334. e = (struct rt_event *)obj;
  335. if (!rt_list_isempty(&e->parent.suspend_thread))
  336. {
  337. rt_kprintf("%-*.*s 0x%08x %03d:",
  338. maxlen, RT_NAME_MAX,
  339. e->parent.parent.name,
  340. e->set,
  341. rt_list_len(&e->parent.suspend_thread));
  342. show_wait_queue(&(e->parent.suspend_thread));
  343. rt_kprintf("\n");
  344. }
  345. else
  346. {
  347. rt_kprintf("%-*.*s 0x%08x 0\n",
  348. maxlen, RT_NAME_MAX, e->parent.parent.name, e->set);
  349. }
  350. }
  351. }
  352. }
  353. while (next != (rt_list_t *)RT_NULL);
  354. return 0;
  355. }
  356. #endif /* RT_USING_EVENT */
  357. #ifdef RT_USING_MUTEX
  358. long list_mutex(void)
  359. {
  360. rt_base_t level;
  361. list_get_next_t find_arg;
  362. struct rt_object_information *info;
  363. rt_list_t *obj_list[LIST_FIND_OBJ_NR];
  364. rt_list_t *next = (rt_list_t *)RT_NULL;
  365. int maxlen;
  366. const char *item_title = "mutex";
  367. list_find_init(&find_arg, RT_Object_Class_Mutex, obj_list, sizeof(obj_list) / sizeof(obj_list[0]));
  368. info = rt_list_entry(find_arg.list, struct rt_object_information, object_list);
  369. maxlen = RT_NAME_MAX;
  370. rt_kprintf("%-*.*s owner hold priority suspend thread \n", maxlen, maxlen, item_title);
  371. object_split(maxlen);
  372. rt_kprintf(" -------- ---- -------- --------------\n");
  373. do
  374. {
  375. next = list_get_next(next, &find_arg);
  376. {
  377. int i;
  378. for (i = 0; i < find_arg.nr_out; i++)
  379. {
  380. struct rt_object *obj;
  381. struct rt_mutex *m;
  382. obj = rt_list_entry(obj_list[i], struct rt_object, list);
  383. level = rt_spin_lock_irqsave(&info->spinlock);
  384. if ((obj->type & ~RT_Object_Class_Static) != find_arg.type)
  385. {
  386. rt_spin_unlock_irqrestore(&info->spinlock, level);
  387. continue;
  388. }
  389. rt_spin_unlock_irqrestore(&info->spinlock, level);
  390. m = (struct rt_mutex *)obj;
  391. if (!rt_list_isempty(&m->parent.suspend_thread))
  392. {
  393. rt_kprintf("%-*.*s %-8.*s %04d %8d %04d ",
  394. maxlen, RT_NAME_MAX,
  395. m->parent.parent.name,
  396. RT_NAME_MAX,
  397. m->owner->parent.name,
  398. m->hold,
  399. m->priority,
  400. rt_list_len(&m->parent.suspend_thread));
  401. show_wait_queue(&(m->parent.suspend_thread));
  402. rt_kprintf("\n");
  403. }
  404. else
  405. {
  406. rt_kprintf("%-*.*s %-8.*s %04d %8d %04d\n",
  407. maxlen, RT_NAME_MAX,
  408. m->parent.parent.name,
  409. RT_NAME_MAX,
  410. m->owner->parent.name,
  411. m->hold,
  412. m->priority,
  413. rt_list_len(&m->parent.suspend_thread));
  414. }
  415. }
  416. }
  417. }
  418. while (next != (rt_list_t *)RT_NULL);
  419. return 0;
  420. }
  421. #endif /* RT_USING_MUTEX */
  422. #ifdef RT_USING_MAILBOX
  423. long list_mailbox(void)
  424. {
  425. rt_base_t level;
  426. list_get_next_t find_arg;
  427. struct rt_object_information *info;
  428. rt_list_t *obj_list[LIST_FIND_OBJ_NR];
  429. rt_list_t *next = (rt_list_t *)RT_NULL;
  430. int maxlen;
  431. const char *item_title = "mailbox";
  432. list_find_init(&find_arg, RT_Object_Class_MailBox, obj_list, sizeof(obj_list) / sizeof(obj_list[0]));
  433. info = rt_list_entry(find_arg.list, struct rt_object_information, object_list);
  434. maxlen = RT_NAME_MAX;
  435. rt_kprintf("%-*.*s entry size suspend thread\n", maxlen, maxlen, item_title);
  436. object_split(maxlen);
  437. rt_kprintf(" ---- ---- --------------\n");
  438. do
  439. {
  440. next = list_get_next(next, &find_arg);
  441. {
  442. int i;
  443. for (i = 0; i < find_arg.nr_out; i++)
  444. {
  445. struct rt_object *obj;
  446. struct rt_mailbox *m;
  447. obj = rt_list_entry(obj_list[i], struct rt_object, list);
  448. level = rt_spin_lock_irqsave(&info->spinlock);
  449. if ((obj->type & ~RT_Object_Class_Static) != find_arg.type)
  450. {
  451. rt_spin_unlock_irqrestore(&info->spinlock, level);
  452. continue;
  453. }
  454. rt_spin_unlock_irqrestore(&info->spinlock, level);
  455. m = (struct rt_mailbox *)obj;
  456. if (!rt_list_isempty(&m->parent.suspend_thread))
  457. {
  458. rt_kprintf("%-*.*s %04d %04d %d:",
  459. maxlen, RT_NAME_MAX,
  460. m->parent.parent.name,
  461. m->entry,
  462. m->size,
  463. rt_list_len(&m->parent.suspend_thread));
  464. show_wait_queue(&(m->parent.suspend_thread));
  465. rt_kprintf("\n");
  466. }
  467. else
  468. {
  469. rt_kprintf("%-*.*s %04d %04d %d\n",
  470. maxlen, RT_NAME_MAX,
  471. m->parent.parent.name,
  472. m->entry,
  473. m->size,
  474. rt_list_len(&m->parent.suspend_thread));
  475. }
  476. }
  477. }
  478. }
  479. while (next != (rt_list_t *)RT_NULL);
  480. return 0;
  481. }
  482. #endif /* RT_USING_MAILBOX */
  483. #ifdef RT_USING_MESSAGEQUEUE
  484. long list_msgqueue(void)
  485. {
  486. rt_base_t level;
  487. list_get_next_t find_arg;
  488. struct rt_object_information *info;
  489. rt_list_t *obj_list[LIST_FIND_OBJ_NR];
  490. rt_list_t *next = (rt_list_t *)RT_NULL;
  491. int maxlen;
  492. const char *item_title = "msgqueue";
  493. list_find_init(&find_arg, RT_Object_Class_MessageQueue, obj_list, sizeof(obj_list) / sizeof(obj_list[0]));
  494. info = rt_list_entry(find_arg.list, struct rt_object_information, object_list);
  495. maxlen = RT_NAME_MAX;
  496. rt_kprintf("%-*.*s entry suspend thread\n", maxlen, maxlen, item_title);
  497. object_split(maxlen);
  498. rt_kprintf(" ---- --------------\n");
  499. do
  500. {
  501. next = list_get_next(next, &find_arg);
  502. {
  503. int i;
  504. for (i = 0; i < find_arg.nr_out; i++)
  505. {
  506. struct rt_object *obj;
  507. struct rt_messagequeue *m;
  508. obj = rt_list_entry(obj_list[i], struct rt_object, list);
  509. level = rt_spin_lock_irqsave(&info->spinlock);
  510. if ((obj->type & ~RT_Object_Class_Static) != find_arg.type)
  511. {
  512. rt_spin_unlock_irqrestore(&info->spinlock, level);
  513. continue;
  514. }
  515. rt_spin_unlock_irqrestore(&info->spinlock, level);
  516. m = (struct rt_messagequeue *)obj;
  517. if (!rt_list_isempty(&m->parent.suspend_thread))
  518. {
  519. rt_kprintf("%-*.*s %04d %d:",
  520. maxlen, RT_NAME_MAX,
  521. m->parent.parent.name,
  522. m->entry,
  523. rt_list_len(&m->parent.suspend_thread));
  524. show_wait_queue(&(m->parent.suspend_thread));
  525. rt_kprintf("\n");
  526. }
  527. else
  528. {
  529. rt_kprintf("%-*.*s %04d %d\n",
  530. maxlen, RT_NAME_MAX,
  531. m->parent.parent.name,
  532. m->entry,
  533. rt_list_len(&m->parent.suspend_thread));
  534. }
  535. }
  536. }
  537. }
  538. while (next != (rt_list_t *)RT_NULL);
  539. return 0;
  540. }
  541. #endif /* RT_USING_MESSAGEQUEUE */
  542. #ifdef RT_USING_MEMHEAP
  543. long list_memheap(void)
  544. {
  545. rt_base_t level;
  546. list_get_next_t find_arg;
  547. struct rt_object_information *info;
  548. rt_list_t *obj_list[LIST_FIND_OBJ_NR];
  549. rt_list_t *next = (rt_list_t *)RT_NULL;
  550. int maxlen;
  551. const char *item_title = "memheap";
  552. list_find_init(&find_arg, RT_Object_Class_MemHeap, obj_list, sizeof(obj_list) / sizeof(obj_list[0]));
  553. info = rt_list_entry(find_arg.list, struct rt_object_information, object_list);
  554. maxlen = RT_NAME_MAX;
  555. rt_kprintf("%-*.*s pool size max used size available size\n", maxlen, maxlen, item_title);
  556. object_split(maxlen);
  557. rt_kprintf(" ---------- ------------- --------------\n");
  558. do
  559. {
  560. next = list_get_next(next, &find_arg);
  561. {
  562. int i;
  563. for (i = 0; i < find_arg.nr_out; i++)
  564. {
  565. struct rt_object *obj;
  566. struct rt_memheap *mh;
  567. obj = rt_list_entry(obj_list[i], struct rt_object, list);
  568. level = rt_spin_lock_irqsave(&info->spinlock);
  569. if ((obj->type & ~RT_Object_Class_Static) != find_arg.type)
  570. {
  571. rt_spin_unlock_irqrestore(&info->spinlock, level);
  572. continue;
  573. }
  574. rt_spin_unlock_irqrestore(&info->spinlock, level);
  575. mh = (struct rt_memheap *)obj;
  576. rt_kprintf("%-*.*s %-010d %-013d %-05d\n",
  577. maxlen, RT_NAME_MAX,
  578. mh->parent.name,
  579. mh->pool_size,
  580. mh->max_used_size,
  581. mh->available_size);
  582. }
  583. }
  584. }
  585. while (next != (rt_list_t *)RT_NULL);
  586. return 0;
  587. }
  588. #endif /* RT_USING_MEMHEAP */
  589. #ifdef RT_USING_MEMPOOL
  590. long list_mempool(void)
  591. {
  592. rt_base_t level;
  593. list_get_next_t find_arg;
  594. struct rt_object_information *info;
  595. rt_list_t *obj_list[LIST_FIND_OBJ_NR];
  596. rt_list_t *next = (rt_list_t *)RT_NULL;
  597. int maxlen;
  598. const char *item_title = "mempool";
  599. list_find_init(&find_arg, RT_Object_Class_MemPool, obj_list, sizeof(obj_list) / sizeof(obj_list[0]));
  600. info = rt_list_entry(find_arg.list, struct rt_object_information, object_list);
  601. maxlen = RT_NAME_MAX;
  602. rt_kprintf("%-*.*s block total free suspend thread\n", maxlen, maxlen, item_title);
  603. object_split(maxlen);
  604. rt_kprintf(" ---- ---- ---- --------------\n");
  605. do
  606. {
  607. next = list_get_next(next, &find_arg);
  608. {
  609. int i;
  610. for (i = 0; i < find_arg.nr_out; i++)
  611. {
  612. struct rt_object *obj;
  613. struct rt_mempool *mp;
  614. int suspend_thread_count;
  615. rt_list_t *node;
  616. obj = rt_list_entry(obj_list[i], struct rt_object, list);
  617. level = rt_spin_lock_irqsave(&info->spinlock);
  618. if ((obj->type & ~RT_Object_Class_Static) != find_arg.type)
  619. {
  620. rt_spin_unlock_irqrestore(&info->spinlock, level);
  621. continue;
  622. }
  623. rt_spin_unlock_irqrestore(&info->spinlock, level);
  624. mp = (struct rt_mempool *)obj;
  625. suspend_thread_count = 0;
  626. rt_list_for_each(node, &mp->suspend_thread)
  627. {
  628. suspend_thread_count++;
  629. }
  630. if (suspend_thread_count > 0)
  631. {
  632. rt_kprintf("%-*.*s %04d %04d %04d %d:",
  633. maxlen, RT_NAME_MAX,
  634. mp->parent.name,
  635. mp->block_size,
  636. mp->block_total_count,
  637. mp->block_free_count,
  638. suspend_thread_count);
  639. show_wait_queue(&(mp->suspend_thread));
  640. rt_kprintf("\n");
  641. }
  642. else
  643. {
  644. rt_kprintf("%-*.*s %04d %04d %04d %d\n",
  645. maxlen, RT_NAME_MAX,
  646. mp->parent.name,
  647. mp->block_size,
  648. mp->block_total_count,
  649. mp->block_free_count,
  650. suspend_thread_count);
  651. }
  652. }
  653. }
  654. }
  655. while (next != (rt_list_t *)RT_NULL);
  656. return 0;
  657. }
  658. #endif /* RT_USING_MEMPOOL */
  659. long list_timer(void)
  660. {
  661. rt_base_t level;
  662. list_get_next_t find_arg;
  663. struct rt_object_information *info;
  664. rt_list_t *obj_list[LIST_FIND_OBJ_NR];
  665. rt_list_t *next = (rt_list_t *)RT_NULL;
  666. int maxlen;
  667. const char *item_title = "timer";
  668. list_find_init(&find_arg, RT_Object_Class_Timer, obj_list, sizeof(obj_list) / sizeof(obj_list[0]));
  669. info = rt_list_entry(find_arg.list, struct rt_object_information, object_list);
  670. maxlen = RT_NAME_MAX;
  671. rt_kprintf("%-*.*s periodic timeout activated mode\n", maxlen, maxlen, item_title);
  672. object_split(maxlen);
  673. rt_kprintf(" ---------- ---------- ----------- ---------\n");
  674. do
  675. {
  676. next = list_get_next(next, &find_arg);
  677. {
  678. int i;
  679. for (i = 0; i < find_arg.nr_out; i++)
  680. {
  681. struct rt_object *obj;
  682. struct rt_timer *timer;
  683. obj = rt_list_entry(obj_list[i], struct rt_object, list);
  684. level = rt_spin_lock_irqsave(&info->spinlock);
  685. if ((obj->type & ~RT_Object_Class_Static) != find_arg.type)
  686. {
  687. rt_spin_unlock_irqrestore(&info->spinlock, level);
  688. continue;
  689. }
  690. rt_spin_unlock_irqrestore(&info->spinlock, level);
  691. timer = (struct rt_timer *)obj;
  692. rt_kprintf("%-*.*s 0x%08x 0x%08x ",
  693. maxlen, RT_NAME_MAX,
  694. timer->parent.name,
  695. timer->init_tick,
  696. timer->timeout_tick);
  697. if (timer->parent.flag & RT_TIMER_FLAG_ACTIVATED)
  698. rt_kprintf("activated ");
  699. else
  700. rt_kprintf("deactivated ");
  701. if (timer->parent.flag & RT_TIMER_FLAG_PERIODIC)
  702. rt_kprintf("periodic\n");
  703. else
  704. rt_kprintf("one shot\n");
  705. }
  706. }
  707. }
  708. while (next != (rt_list_t *)RT_NULL);
  709. rt_kprintf("current tick:0x%08x\n", rt_tick_get());
  710. return 0;
  711. }
  712. #ifdef RT_USING_DEVICE
  713. static char *const device_type_str[RT_Device_Class_Unknown] =
  714. {
  715. "Character Device",
  716. "Block Device",
  717. "Network Interface",
  718. "MTD Device",
  719. "CAN Device",
  720. "RTC",
  721. "Sound Device",
  722. "Graphic Device",
  723. "I2C Bus",
  724. "USB Slave Device",
  725. "USB Host Bus",
  726. "USB OTG Bus",
  727. "SPI Bus",
  728. "SPI Device",
  729. "SDIO Bus",
  730. "PM Pseudo Device",
  731. "Pipe",
  732. "Portal Device",
  733. "Timer Device",
  734. "Miscellaneous Device",
  735. "Sensor Device",
  736. "Touch Device",
  737. "Phy Device",
  738. "Security Device",
  739. "WLAN Device",
  740. "Pin Device",
  741. "ADC Device",
  742. "DAC Device",
  743. "WDT Device",
  744. "PWM Device",
  745. "Bus Device",
  746. };
  747. long list_device(void)
  748. {
  749. rt_base_t level;
  750. list_get_next_t find_arg;
  751. struct rt_object_information *info;
  752. rt_list_t *obj_list[LIST_FIND_OBJ_NR];
  753. rt_list_t *next = (rt_list_t *)RT_NULL;
  754. const char *device_type;
  755. int maxlen;
  756. const char *item_title = "device";
  757. list_find_init(&find_arg, RT_Object_Class_Device, obj_list, sizeof(obj_list) / sizeof(obj_list[0]));
  758. info = rt_list_entry(find_arg.list, struct rt_object_information, object_list);
  759. maxlen = RT_NAME_MAX;
  760. rt_kprintf("%-*.*s type ref count\n", maxlen, maxlen, item_title);
  761. object_split(maxlen);
  762. rt_kprintf(" -------------------- ----------\n");
  763. do
  764. {
  765. next = list_get_next(next, &find_arg);
  766. {
  767. int i;
  768. for (i = 0; i < find_arg.nr_out; i++)
  769. {
  770. struct rt_object *obj;
  771. struct rt_device *device;
  772. obj = rt_list_entry(obj_list[i], struct rt_object, list);
  773. level = rt_spin_lock_irqsave(&info->spinlock);
  774. if ((obj->type & ~RT_Object_Class_Static) != find_arg.type)
  775. {
  776. rt_spin_unlock_irqrestore(&info->spinlock, level);
  777. continue;
  778. }
  779. rt_spin_unlock_irqrestore(&info->spinlock, level);
  780. device = (struct rt_device *)obj;
  781. device_type = "Unknown";
  782. if (device->type < RT_Device_Class_Unknown &&
  783. device_type_str[device->type] != RT_NULL)
  784. {
  785. device_type = device_type_str[device->type];
  786. }
  787. rt_kprintf("%-*.*s %-20s %-8d\n",
  788. maxlen, RT_NAME_MAX,
  789. device->parent.name,
  790. device_type,
  791. device->ref_count);
  792. }
  793. }
  794. }
  795. while (next != (rt_list_t *)RT_NULL);
  796. return 0;
  797. }
  798. #endif /* RT_USING_DEVICE */
  799. #ifndef FINSH_USING_OPTION_COMPLETION
  800. int cmd_list(int argc, char **argv)
  801. {
  802. if(argc == 2)
  803. {
  804. if(strcmp(argv[1], "thread") == 0)
  805. {
  806. list_thread();
  807. }
  808. else if(strcmp(argv[1], "timer") == 0)
  809. {
  810. list_timer();
  811. }
  812. #ifdef RT_USING_SEMAPHORE
  813. else if(strcmp(argv[1], "sem") == 0)
  814. {
  815. list_sem();
  816. }
  817. #endif /* RT_USING_SEMAPHORE */
  818. #ifdef RT_USING_EVENT
  819. else if(strcmp(argv[1], "event") == 0)
  820. {
  821. list_event();
  822. }
  823. #endif /* RT_USING_EVENT */
  824. #ifdef RT_USING_MUTEX
  825. else if(strcmp(argv[1], "mutex") == 0)
  826. {
  827. list_mutex();
  828. }
  829. #endif /* RT_USING_MUTEX */
  830. #ifdef RT_USING_MAILBOX
  831. else if(strcmp(argv[1], "mailbox") == 0)
  832. {
  833. list_mailbox();
  834. }
  835. #endif /* RT_USING_MAILBOX */
  836. #ifdef RT_USING_MESSAGEQUEUE
  837. else if(strcmp(argv[1], "msgqueue") == 0)
  838. {
  839. list_msgqueue();
  840. }
  841. #endif /* RT_USING_MESSAGEQUEUE */
  842. #ifdef RT_USING_MEMHEAP
  843. else if(strcmp(argv[1], "memheap") == 0)
  844. {
  845. list_memheap();
  846. }
  847. #endif /* RT_USING_MEMHEAP */
  848. #ifdef RT_USING_MEMPOOL
  849. else if(strcmp(argv[1], "mempool") == 0)
  850. {
  851. list_mempool();
  852. }
  853. #endif /* RT_USING_MEMPOOL */
  854. #ifdef RT_USING_DEVICE
  855. else if(strcmp(argv[1], "device") == 0)
  856. {
  857. list_device();
  858. }
  859. #endif /* RT_USING_DEVICE */
  860. #ifdef RT_USING_DFS
  861. else if(strcmp(argv[1], "fd") == 0)
  862. {
  863. extern int list_fd(void);
  864. list_fd();
  865. }
  866. #endif /* RT_USING_DFS */
  867. else
  868. {
  869. goto _usage;
  870. }
  871. return 0;
  872. }
  873. _usage:
  874. rt_kprintf("Usage: list [options]\n");
  875. rt_kprintf("[options]:\n");
  876. rt_kprintf(" %-12s - list threads\n", "thread");
  877. rt_kprintf(" %-12s - list timers\n", "timer");
  878. #ifdef RT_USING_SEMAPHORE
  879. rt_kprintf(" %-12s - list semaphores\n", "sem");
  880. #endif /* RT_USING_SEMAPHORE */
  881. #ifdef RT_USING_MUTEX
  882. rt_kprintf(" %-12s - list mutexs\n", "mutex");
  883. #endif /* RT_USING_MUTEX */
  884. #ifdef RT_USING_EVENT
  885. rt_kprintf(" %-12s - list events\n", "event");
  886. #endif /* RT_USING_EVENT */
  887. #ifdef RT_USING_MAILBOX
  888. rt_kprintf(" %-12s - list mailboxs\n", "mailbox");
  889. #endif /* RT_USING_MAILBOX */
  890. #ifdef RT_USING_MESSAGEQUEUE
  891. rt_kprintf(" %-12s - list message queues\n", "msgqueue");
  892. #endif /* RT_USING_MESSAGEQUEUE */
  893. #ifdef RT_USING_MEMHEAP
  894. rt_kprintf(" %-12s - list memory heaps\n", "memheap");
  895. #endif /* RT_USING_MEMHEAP */
  896. #ifdef RT_USING_MEMPOOL
  897. rt_kprintf(" %-12s - list memory pools\n", "mempool");
  898. #endif /* RT_USING_MEMPOOL */
  899. #ifdef RT_USING_DEVICE
  900. rt_kprintf(" %-12s - list devices\n", "device");
  901. #endif /* RT_USING_DEVICE */
  902. #ifdef RT_USING_DFS
  903. rt_kprintf(" %-12s - list file descriptors\n", "fd");
  904. #endif /* RT_USING_DFS */
  905. return 0;
  906. }
  907. #else
  908. CMD_OPTIONS_STATEMENT(cmd_list)
  909. int cmd_list(int argc, char **argv)
  910. {
  911. if (argc == 2)
  912. {
  913. switch (MSH_OPT_ID_GET(cmd_list))
  914. {
  915. case RT_Object_Class_Thread: list_thread(); break;
  916. case RT_Object_Class_Timer: list_timer(); break;
  917. #ifdef RT_USING_SEMAPHORE
  918. case RT_Object_Class_Semaphore: list_sem(); break;
  919. #endif /* RT_USING_SEMAPHORE */
  920. #ifdef RT_USING_EVENT
  921. case RT_Object_Class_Event: list_event(); break;
  922. #endif /* RT_USING_EVENT */
  923. #ifdef RT_USING_MUTEX
  924. case RT_Object_Class_Mutex: list_mutex(); break;
  925. #endif /* RT_USING_MUTEX */
  926. #ifdef RT_USING_MAILBOX
  927. case RT_Object_Class_MailBox: list_mailbox(); break;
  928. #endif /* RT_USING_MAILBOX */
  929. #ifdef RT_USING_MESSAGEQUEUE
  930. case RT_Object_Class_MessageQueue: list_msgqueue(); break;
  931. #endif /* RT_USING_MESSAGEQUEUE */
  932. #ifdef RT_USING_MEMHEAP
  933. case RT_Object_Class_MemHeap: list_memheap(); break;
  934. #endif /* RT_USING_MEMHEAP */
  935. #ifdef RT_USING_MEMPOOL
  936. case RT_Object_Class_MemPool: list_mempool(); break;
  937. #endif /* RT_USING_MEMPOOL */
  938. #ifdef RT_USING_DEVICE
  939. case RT_Object_Class_Device: list_device(); break;
  940. #endif /* RT_USING_DEVICE */
  941. #ifdef RT_USING_DFS
  942. case LIST_DFS_OPT_ID:
  943. {
  944. extern int list_fd(void);
  945. list_fd();
  946. break;
  947. }
  948. #endif /* RT_USING_DFS */
  949. default:
  950. goto _usage;
  951. break;
  952. };
  953. return 0;
  954. }
  955. _usage:
  956. rt_kprintf("Usage: list [options]\n");
  957. rt_kprintf("[options]:\n");
  958. MSH_OPT_DUMP(cmd_list);
  959. return 0;
  960. }
  961. CMD_OPTIONS_NODE_START(cmd_list)
  962. CMD_OPTIONS_NODE(RT_Object_Class_Thread, thread, list threads)
  963. CMD_OPTIONS_NODE(RT_Object_Class_Timer, timer, list timers)
  964. #ifdef RT_USING_SEMAPHORE
  965. CMD_OPTIONS_NODE(RT_Object_Class_Semaphore, sem, list semaphores)
  966. #endif /* RT_USING_SEMAPHORE */
  967. #ifdef RT_USING_EVENT
  968. CMD_OPTIONS_NODE(RT_Object_Class_Event, event, list events)
  969. #endif /* RT_USING_EVENT */
  970. #ifdef RT_USING_MUTEX
  971. CMD_OPTIONS_NODE(RT_Object_Class_Mutex, mutex, list mutexs)
  972. #endif /* RT_USING_MUTEX */
  973. #ifdef RT_USING_MAILBOX
  974. CMD_OPTIONS_NODE(RT_Object_Class_MailBox, mailbox, list mailboxs)
  975. #endif /* RT_USING_MAILBOX */
  976. #ifdef RT_USING_MESSAGEQUEUE
  977. CMD_OPTIONS_NODE(RT_Object_Class_MessageQueue, msgqueue, list message queues)
  978. #endif /* RT_USING_MESSAGEQUEUE */
  979. #ifdef RT_USING_MEMHEAP
  980. CMD_OPTIONS_NODE(RT_Object_Class_MemHeap, memheap, list memory heaps)
  981. #endif /* RT_USING_MEMHEAP */
  982. #ifdef RT_USING_MEMPOOL
  983. CMD_OPTIONS_NODE(RT_Object_Class_MemPool, mempool, list memory pools)
  984. #endif /* RT_USING_MEMPOOL */
  985. #ifdef RT_USING_DEVICE
  986. CMD_OPTIONS_NODE(RT_Object_Class_Device, device, list devices)
  987. #endif /* RT_USING_DEVICE */
  988. #ifdef RT_USING_DFS
  989. CMD_OPTIONS_NODE(LIST_DFS_OPT_ID, fd, list file descriptors)
  990. #endif /* RT_USING_DFS */
  991. CMD_OPTIONS_NODE_END
  992. #endif /* FINSH_USING_OPTION_COMPLETION */
  993. MSH_CMD_EXPORT_ALIAS(cmd_list, list, list objects, optenable);
  994. #endif /* RT_USING_FINSH */