source: mainline/kernel/generic/src/console/cmd.c@ 5b7a107

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 5b7a107 was 5b7a107, checked in by Martin Decky <martin@…>, 15 years ago

as the 'btrace' command depends on udebug, make it optional on CONFIG_UDEBUG
  • Property mode set to 100644
File size: 27.9 KB
Line 
1/*
2 * Copyright (c) 2005 Jakub Jermar
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup genericconsole
30 * @{
31 */
32
33/**
34 * @file cmd.c
35 * @brief Kernel console command wrappers.
36 *
37 * This file is meant to contain all wrapper functions for
38 * all kconsole commands. The point is in separating
39 * kconsole specific wrappers from kconsole-unaware functions
40 * from other subsystems.
41 */
42
43#include <console/cmd.h>
44#include <console/console.h>
45#include <console/kconsole.h>
46#include <print.h>
47#include <panic.h>
48#include <typedefs.h>
49#include <adt/list.h>
50#include <arch.h>
51#include <config.h>
52#include <func.h>
53#include <str.h>
54#include <macros.h>
55#include <debug.h>
56#include <cpu.h>
57#include <mm/tlb.h>
58#include <arch/mm/tlb.h>
59#include <mm/frame.h>
60#include <main/version.h>
61#include <mm/slab.h>
62#include <proc/scheduler.h>
63#include <proc/thread.h>
64#include <proc/task.h>
65#include <ipc/ipc.h>
66#include <ipc/irq.h>
67#include <ipc/event.h>
68#include <sysinfo/sysinfo.h>
69#include <symtab.h>
70#include <errno.h>
71
72#ifdef CONFIG_TEST
73#include <test.h>
74#endif
75
76/* Data and methods for 'help' command. */
77static int cmd_help(cmd_arg_t *argv);
78static cmd_info_t help_info = {
79 .name = "help",
80 .description = "List supported commands.",
81 .func = cmd_help,
82 .argc = 0
83};
84
85/* Data and methods for 'reboot' command. */
86static int cmd_reboot(cmd_arg_t *argv);
87static cmd_info_t reboot_info = {
88 .name = "reboot",
89 .description = "Reboot system.",
90 .func = cmd_reboot,
91 .argc = 0
92};
93
94/* Data and methods for 'uptime' command. */
95static int cmd_uptime(cmd_arg_t *argv);
96static cmd_info_t uptime_info = {
97 .name = "uptime",
98 .description = "Show system uptime.",
99 .func = cmd_uptime,
100 .argc = 0
101};
102
103/* Data and methods for 'continue' command. */
104static int cmd_continue(cmd_arg_t *argv);
105static cmd_info_t continue_info = {
106 .name = "continue",
107 .description = "Return console back to userspace.",
108 .func = cmd_continue,
109 .argc = 0
110};
111
112#ifdef CONFIG_TEST
113
114/* Data and methods for 'test' command. */
115static char test_buf[MAX_CMDLINE + 1];
116static int cmd_test(cmd_arg_t *argv);
117static cmd_arg_t test_argv[] = {
118 {
119 .type = ARG_TYPE_STRING_OPTIONAL,
120 .buffer = test_buf,
121 .len = sizeof(test_buf)
122 }
123};
124static cmd_info_t test_info = {
125 .name = "test",
126 .description = "<test> List kernel tests or run a test.",
127 .func = cmd_test,
128 .argc = 1,
129 .argv = test_argv
130};
131
132/* Data and methods for 'bench' command. */
133static int cmd_bench(cmd_arg_t *argv);
134static cmd_arg_t bench_argv[] = {
135 {
136 .type = ARG_TYPE_STRING,
137 .buffer = test_buf,
138 .len = sizeof(test_buf)
139 },
140 {
141 .type = ARG_TYPE_INT,
142 }
143};
144static cmd_info_t bench_info = {
145 .name = "bench",
146 .description = "<test> <count> Run kernel test as benchmark.",
147 .func = cmd_bench,
148 .argc = 2,
149 .argv = bench_argv
150};
151
152#endif /* CONFIG_TEST */
153
154/* Data and methods for 'description' command. */
155static int cmd_desc(cmd_arg_t *argv);
156static void desc_help(void);
157static char desc_buf[MAX_CMDLINE + 1];
158static cmd_arg_t desc_argv = {
159 .type = ARG_TYPE_STRING,
160 .buffer = desc_buf,
161 .len = sizeof(desc_buf)
162};
163static cmd_info_t desc_info = {
164 .name = "describe",
165 .description = "<command> Describe specified command.",
166 .help = desc_help,
167 .func = cmd_desc,
168 .argc = 1,
169 .argv = &desc_argv
170};
171
172/* Data and methods for 'symaddr' command. */
173static int cmd_symaddr(cmd_arg_t *argv);
174static char symaddr_buf[MAX_CMDLINE + 1];
175static cmd_arg_t symaddr_argv = {
176 .type = ARG_TYPE_STRING,
177 .buffer = symaddr_buf,
178 .len = sizeof(symaddr_buf)
179};
180static cmd_info_t symaddr_info = {
181 .name = "symaddr",
182 .description = "<symbol> Return symbol address.",
183 .func = cmd_symaddr,
184 .argc = 1,
185 .argv = &symaddr_argv
186};
187
188/* Data and methods for 'set4' command. */
189static char set_buf[MAX_CMDLINE + 1];
190static int cmd_set4(cmd_arg_t *argv);
191static cmd_arg_t set4_argv[] = {
192 {
193 .type = ARG_TYPE_STRING,
194 .buffer = set_buf,
195 .len = sizeof(set_buf)
196 },
197 {
198 .type = ARG_TYPE_INT
199 }
200};
201static cmd_info_t set4_info = {
202 .name = "set4",
203 .description = "<addr> <value> Set 4B memory location to a value.",
204 .func = cmd_set4,
205 .argc = 2,
206 .argv = set4_argv
207};
208
209/* Data and methods for 'call0' and 'mcall0' command. */
210static char call0_buf[MAX_CMDLINE + 1];
211static char carg1_buf[MAX_CMDLINE + 1];
212static char carg2_buf[MAX_CMDLINE + 1];
213static char carg3_buf[MAX_CMDLINE + 1];
214
215static int cmd_call0(cmd_arg_t *argv);
216static cmd_arg_t call0_argv = {
217 .type = ARG_TYPE_STRING,
218 .buffer = call0_buf,
219 .len = sizeof(call0_buf)
220};
221static cmd_info_t call0_info = {
222 .name = "call0",
223 .description = "<function> Call function().",
224 .func = cmd_call0,
225 .argc = 1,
226 .argv = &call0_argv
227};
228
229/* Data and methods for 'mcall0' command. */
230static int cmd_mcall0(cmd_arg_t *argv);
231static cmd_arg_t mcall0_argv = {
232 .type = ARG_TYPE_STRING,
233 .buffer = call0_buf,
234 .len = sizeof(call0_buf)
235};
236static cmd_info_t mcall0_info = {
237 .name = "mcall0",
238 .description = "<function> Call function() on each CPU.",
239 .func = cmd_mcall0,
240 .argc = 1,
241 .argv = &mcall0_argv
242};
243
244/* Data and methods for 'call1' command. */
245static int cmd_call1(cmd_arg_t *argv);
246static cmd_arg_t call1_argv[] = {
247 {
248 .type = ARG_TYPE_STRING,
249 .buffer = call0_buf,
250 .len = sizeof(call0_buf)
251 },
252 {
253 .type = ARG_TYPE_VAR,
254 .buffer = carg1_buf,
255 .len = sizeof(carg1_buf)
256 }
257};
258static cmd_info_t call1_info = {
259 .name = "call1",
260 .description = "<function> <arg1> Call function(arg1).",
261 .func = cmd_call1,
262 .argc = 2,
263 .argv = call1_argv
264};
265
266/* Data and methods for 'call2' command. */
267static int cmd_call2(cmd_arg_t *argv);
268static cmd_arg_t call2_argv[] = {
269 {
270 .type = ARG_TYPE_STRING,
271 .buffer = call0_buf,
272 .len = sizeof(call0_buf)
273 },
274 {
275 .type = ARG_TYPE_VAR,
276 .buffer = carg1_buf,
277 .len = sizeof(carg1_buf)
278 },
279 {
280 .type = ARG_TYPE_VAR,
281 .buffer = carg2_buf,
282 .len = sizeof(carg2_buf)
283 }
284};
285static cmd_info_t call2_info = {
286 .name = "call2",
287 .description = "<function> <arg1> <arg2> Call function(arg1, arg2).",
288 .func = cmd_call2,
289 .argc = 3,
290 .argv = call2_argv
291};
292
293/* Data and methods for 'call3' command. */
294static int cmd_call3(cmd_arg_t *argv);
295static cmd_arg_t call3_argv[] = {
296 {
297 .type = ARG_TYPE_STRING,
298 .buffer = call0_buf,
299 .len = sizeof(call0_buf)
300 },
301 {
302 .type = ARG_TYPE_VAR,
303 .buffer = carg1_buf,
304 .len = sizeof(carg1_buf)
305 },
306 {
307 .type = ARG_TYPE_VAR,
308 .buffer = carg2_buf,
309 .len = sizeof(carg2_buf)
310 },
311 {
312 .type = ARG_TYPE_VAR,
313 .buffer = carg3_buf,
314 .len = sizeof(carg3_buf)
315 }
316
317};
318static cmd_info_t call3_info = {
319 .name = "call3",
320 .description = "<function> <arg1> <arg2> <arg3> Call function(arg1, arg2, arg3).",
321 .func = cmd_call3,
322 .argc = 4,
323 .argv = call3_argv
324};
325
326/* Data and methods for 'halt' command. */
327static int cmd_halt(cmd_arg_t *argv);
328static cmd_info_t halt_info = {
329 .name = "halt",
330 .description = "Halt the kernel.",
331 .func = cmd_halt,
332 .argc = 0
333};
334
335/* Data and methods for 'physmem' command. */
336static int cmd_physmem(cmd_arg_t *argv);
337cmd_info_t physmem_info = {
338 .name = "physmem",
339 .description = "Print physical memory configuration.",
340 .help = NULL,
341 .func = cmd_physmem,
342 .argc = 0,
343 .argv = NULL
344};
345
346/* Data and methods for 'tlb' command. */
347static int cmd_tlb(cmd_arg_t *argv);
348cmd_info_t tlb_info = {
349 .name = "tlb",
350 .description = "Print TLB of the current CPU.",
351 .help = NULL,
352 .func = cmd_tlb,
353 .argc = 0,
354 .argv = NULL
355};
356
357static char flag_buf[MAX_CMDLINE + 1];
358
359static int cmd_threads(cmd_arg_t *argv);
360static cmd_arg_t threads_argv = {
361 .type = ARG_TYPE_STRING_OPTIONAL,
362 .buffer = flag_buf,
363 .len = sizeof(flag_buf)
364};
365static cmd_info_t threads_info = {
366 .name = "threads",
367 .description = "List all threads (use -a for additional information).",
368 .func = cmd_threads,
369 .argc = 1,
370 .argv = &threads_argv
371};
372
373static int cmd_tasks(cmd_arg_t *argv);
374static cmd_arg_t tasks_argv = {
375 .type = ARG_TYPE_STRING_OPTIONAL,
376 .buffer = flag_buf,
377 .len = sizeof(flag_buf)
378};
379static cmd_info_t tasks_info = {
380 .name = "tasks",
381 .description = "List all tasks (use -a for additional information).",
382 .func = cmd_tasks,
383 .argc = 1,
384 .argv = &tasks_argv
385};
386
387#ifdef CONFIG_UDEBUG
388
389/* Data and methods for 'btrace' command */
390static int cmd_btrace(cmd_arg_t *argv);
391static cmd_arg_t btrace_argv = {
392 .type = ARG_TYPE_INT,
393};
394static cmd_info_t btrace_info = {
395 .name = "btrace",
396 .description = "<threadid> Show thread stack trace.",
397 .func = cmd_btrace,
398 .argc = 1,
399 .argv = &btrace_argv
400};
401
402#endif /* CONFIG_UDEBUG */
403
404static int cmd_sched(cmd_arg_t *argv);
405static cmd_info_t sched_info = {
406 .name = "scheduler",
407 .description = "Show scheduler information.",
408 .func = cmd_sched,
409 .argc = 0
410};
411
412static int cmd_slabs(cmd_arg_t *argv);
413static cmd_info_t slabs_info = {
414 .name = "slabs",
415 .description = "List slab caches.",
416 .func = cmd_slabs,
417 .argc = 0
418};
419
420static int cmd_sysinfo(cmd_arg_t *argv);
421static cmd_info_t sysinfo_info = {
422 .name = "sysinfo",
423 .description = "Dump sysinfo.",
424 .func = cmd_sysinfo,
425 .argc = 0
426};
427
428/* Data and methods for 'zones' command */
429static int cmd_zones(cmd_arg_t *argv);
430static cmd_info_t zones_info = {
431 .name = "zones",
432 .description = "List memory zones.",
433 .func = cmd_zones,
434 .argc = 0
435};
436
437/* Data and methods for 'zone' command */
438static int cmd_zone(cmd_arg_t *argv);
439static cmd_arg_t zone_argv = {
440 .type = ARG_TYPE_INT,
441};
442
443static cmd_info_t zone_info = {
444 .name = "zone",
445 .description = "<zone> Show memory zone structure.",
446 .func = cmd_zone,
447 .argc = 1,
448 .argv = &zone_argv
449};
450
451/* Data and methods for 'ipc' command */
452static int cmd_ipc(cmd_arg_t *argv);
453static cmd_arg_t ipc_argv = {
454 .type = ARG_TYPE_INT,
455};
456static cmd_info_t ipc_info = {
457 .name = "ipc",
458 .description = "<taskid> Show IPC information of a task.",
459 .func = cmd_ipc,
460 .argc = 1,
461 .argv = &ipc_argv
462};
463
464/* Data and methods for 'kill' command */
465static int cmd_kill(cmd_arg_t *argv);
466static cmd_arg_t kill_argv = {
467 .type = ARG_TYPE_INT,
468};
469static cmd_info_t kill_info = {
470 .name = "kill",
471 .description = "<taskid> Kill a task.",
472 .func = cmd_kill,
473 .argc = 1,
474 .argv = &kill_argv
475};
476
477/* Data and methods for 'cpus' command. */
478static int cmd_cpus(cmd_arg_t *argv);
479cmd_info_t cpus_info = {
480 .name = "cpus",
481 .description = "List all processors.",
482 .help = NULL,
483 .func = cmd_cpus,
484 .argc = 0,
485 .argv = NULL
486};
487
488/* Data and methods for 'version' command. */
489static int cmd_version(cmd_arg_t *argv);
490cmd_info_t version_info = {
491 .name = "version",
492 .description = "Print version information.",
493 .help = NULL,
494 .func = cmd_version,
495 .argc = 0,
496 .argv = NULL
497};
498
499static cmd_info_t *basic_commands[] = {
500 &call0_info,
501 &mcall0_info,
502 &call1_info,
503 &call2_info,
504 &call3_info,
505 &continue_info,
506 &cpus_info,
507 &desc_info,
508 &halt_info,
509 &help_info,
510 &ipc_info,
511 &kill_info,
512 &physmem_info,
513 &reboot_info,
514 &sched_info,
515 &set4_info,
516 &slabs_info,
517 &symaddr_info,
518 &sysinfo_info,
519 &tasks_info,
520 &threads_info,
521 &tlb_info,
522 &uptime_info,
523 &version_info,
524 &zones_info,
525 &zone_info,
526#ifdef CONFIG_TEST
527 &test_info,
528 &bench_info,
529#endif
530#ifdef CONFIG_UDEBUG
531 &btrace_info,
532#endif
533 NULL
534};
535
536
537/** Initialize command info structure.
538 *
539 * @param cmd Command info structure.
540 *
541 */
542void cmd_initialize(cmd_info_t *cmd)
543{
544 spinlock_initialize(&cmd->lock, "cmd.lock");
545 link_initialize(&cmd->link);
546}
547
548/** Initialize and register commands. */
549void cmd_init(void)
550{
551 unsigned int i;
552
553 for (i = 0; basic_commands[i]; i++) {
554 cmd_initialize(basic_commands[i]);
555 if (!cmd_register(basic_commands[i]))
556 printf("Cannot register command %s\n", basic_commands[i]->name);
557 }
558}
559
560/** List supported commands.
561 *
562 * @param argv Argument vector.
563 *
564 * @return 0 on failure, 1 on success.
565 */
566int cmd_help(cmd_arg_t *argv)
567{
568 spinlock_lock(&cmd_lock);
569
570 link_t *cur;
571 size_t len = 0;
572 for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
573 cmd_info_t *hlp;
574 hlp = list_get_instance(cur, cmd_info_t, link);
575
576 spinlock_lock(&hlp->lock);
577 if (str_length(hlp->name) > len)
578 len = str_length(hlp->name);
579 spinlock_unlock(&hlp->lock);
580 }
581
582 unsigned int _len = (unsigned int) len;
583 if ((_len != len) || (((int) _len) < 0)) {
584 printf("Command length overflow\n");
585 return 1;
586 }
587
588 for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
589 cmd_info_t *hlp;
590 hlp = list_get_instance(cur, cmd_info_t, link);
591
592 spinlock_lock(&hlp->lock);
593 printf("%-*s %s\n", _len, hlp->name, hlp->description);
594 spinlock_unlock(&hlp->lock);
595 }
596
597 spinlock_unlock(&cmd_lock);
598
599 return 1;
600}
601
602/** Reboot the system.
603 *
604 * @param argv Argument vector.
605 *
606 * @return 0 on failure, 1 on success.
607 */
608int cmd_reboot(cmd_arg_t *argv)
609{
610 reboot();
611
612 /* Not reached */
613 return 1;
614}
615
616/** Print system uptime information.
617 *
618 * @param argv Argument vector.
619 *
620 * @return 0 on failure, 1 on success.
621 */
622int cmd_uptime(cmd_arg_t *argv)
623{
624 ASSERT(uptime);
625
626 /* This doesn't have to be very accurate */
627 sysarg_t sec = uptime->seconds1;
628
629 printf("Up %" PRIun " days, %" PRIun " hours, %" PRIun " minutes, %" PRIun " seconds\n",
630 sec / 86400, (sec % 86400) / 3600, (sec % 3600) / 60, sec % 60);
631
632 return 1;
633}
634
635/** Describe specified command.
636 *
637 * @param argv Argument vector.
638 *
639 * @return 0 on failure, 1 on success.
640 */
641int cmd_desc(cmd_arg_t *argv)
642{
643 link_t *cur;
644
645 spinlock_lock(&cmd_lock);
646
647 for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
648 cmd_info_t *hlp;
649
650 hlp = list_get_instance(cur, cmd_info_t, link);
651 spinlock_lock(&hlp->lock);
652
653 if (str_lcmp(hlp->name, (const char *) argv->buffer, str_length(hlp->name)) == 0) {
654 printf("%s - %s\n", hlp->name, hlp->description);
655 if (hlp->help)
656 hlp->help();
657 spinlock_unlock(&hlp->lock);
658 break;
659 }
660
661 spinlock_unlock(&hlp->lock);
662 }
663
664 spinlock_unlock(&cmd_lock);
665
666 return 1;
667}
668
669/** Search symbol table */
670int cmd_symaddr(cmd_arg_t *argv)
671{
672 symtab_print_search((char *) argv->buffer);
673
674 return 1;
675}
676
677/** Call function with zero parameters */
678int cmd_call0(cmd_arg_t *argv)
679{
680 uintptr_t symaddr;
681 char *symbol;
682 sysarg_t (*fnc)(void);
683 fncptr_t fptr;
684 int rc;
685
686 symbol = (char *) argv->buffer;
687 rc = symtab_addr_lookup(symbol, &symaddr);
688
689 if (rc == ENOENT)
690 printf("Symbol %s not found.\n", symbol);
691 else if (rc == EOVERFLOW) {
692 symtab_print_search(symbol);
693 printf("Duplicate symbol, be more specific.\n");
694 } else if (rc == EOK) {
695 ipl_t ipl;
696
697 ipl = interrupts_disable();
698 fnc = (sysarg_t (*)(void)) arch_construct_function(&fptr,
699 (void *) symaddr, (void *) cmd_call0);
700 printf("Calling %s() (%p)\n", symbol, (void *) symaddr);
701 printf("Result: %#" PRIxn "\n", fnc());
702 interrupts_restore(ipl);
703 } else {
704 printf("No symbol information available.\n");
705 }
706 return 1;
707}
708
709/** Call function with zero parameters on each CPU */
710int cmd_mcall0(cmd_arg_t *argv)
711{
712 /*
713 * For each CPU, create a thread which will
714 * call the function.
715 */
716
717 unsigned int i;
718 for (i = 0; i < config.cpu_count; i++) {
719 if (!cpus[i].active)
720 continue;
721
722 thread_t *thread;
723 if ((thread = thread_create((void (*)(void *)) cmd_call0,
724 (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
725 irq_spinlock_lock(&thread->lock, true);
726 thread->cpu = &cpus[i];
727 irq_spinlock_unlock(&thread->lock, true);
728
729 printf("cpu%u: ", i);
730
731 thread_ready(thread);
732 thread_join(thread);
733 thread_detach(thread);
734 } else
735 printf("Unable to create thread for cpu%u\n", i);
736 }
737
738 return 1;
739}
740
741/** Call function with one parameter */
742int cmd_call1(cmd_arg_t *argv)
743{
744 uintptr_t symaddr;
745 char *symbol;
746 sysarg_t (*fnc)(sysarg_t, ...);
747 sysarg_t arg1 = argv[1].intval;
748 fncptr_t fptr;
749 int rc;
750
751 symbol = (char *) argv->buffer;
752 rc = symtab_addr_lookup(symbol, &symaddr);
753
754 if (rc == ENOENT) {
755 printf("Symbol %s not found.\n", symbol);
756 } else if (rc == EOVERFLOW) {
757 symtab_print_search(symbol);
758 printf("Duplicate symbol, be more specific.\n");
759 } else if (rc == EOK) {
760 ipl_t ipl;
761
762 ipl = interrupts_disable();
763 fnc = (sysarg_t (*)(sysarg_t, ...))
764 arch_construct_function(&fptr, (void *) symaddr,
765 (void *) cmd_call1);
766 printf("Calling f(%#" PRIxn "): %p: %s\n", arg1,
767 (void *) symaddr, symbol);
768 printf("Result: %#" PRIxn "\n", fnc(arg1));
769 interrupts_restore(ipl);
770 } else {
771 printf("No symbol information available.\n");
772 }
773
774 return 1;
775}
776
777/** Call function with two parameters */
778int cmd_call2(cmd_arg_t *argv)
779{
780 uintptr_t symaddr;
781 char *symbol;
782 sysarg_t (*fnc)(sysarg_t, sysarg_t, ...);
783 sysarg_t arg1 = argv[1].intval;
784 sysarg_t arg2 = argv[2].intval;
785 fncptr_t fptr;
786 int rc;
787
788 symbol = (char *) argv->buffer;
789 rc = symtab_addr_lookup(symbol, &symaddr);
790
791 if (rc == ENOENT) {
792 printf("Symbol %s not found.\n", symbol);
793 } else if (rc == EOVERFLOW) {
794 symtab_print_search(symbol);
795 printf("Duplicate symbol, be more specific.\n");
796 } else if (rc == EOK) {
797 ipl_t ipl;
798
799 ipl = interrupts_disable();
800 fnc = (sysarg_t (*)(sysarg_t, sysarg_t, ...))
801 arch_construct_function(&fptr, (void *) symaddr,
802 (void *) cmd_call2);
803 printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
804 arg1, arg2, (void *) symaddr, symbol);
805 printf("Result: %#" PRIxn "\n", fnc(arg1, arg2));
806 interrupts_restore(ipl);
807 } else {
808 printf("No symbol information available.\n");
809 }
810 return 1;
811}
812
813/** Call function with three parameters */
814int cmd_call3(cmd_arg_t *argv)
815{
816 uintptr_t symaddr;
817 char *symbol;
818 sysarg_t (*fnc)(sysarg_t, sysarg_t, sysarg_t, ...);
819 sysarg_t arg1 = argv[1].intval;
820 sysarg_t arg2 = argv[2].intval;
821 sysarg_t arg3 = argv[3].intval;
822 fncptr_t fptr;
823 int rc;
824
825 symbol = (char *) argv->buffer;
826 rc = symtab_addr_lookup(symbol, &symaddr);
827
828 if (rc == ENOENT) {
829 printf("Symbol %s not found.\n", symbol);
830 } else if (rc == EOVERFLOW) {
831 symtab_print_search(symbol);
832 printf("Duplicate symbol, be more specific.\n");
833 } else if (rc == EOK) {
834 ipl_t ipl;
835
836 ipl = interrupts_disable();
837 fnc = (sysarg_t (*)(sysarg_t, sysarg_t, sysarg_t, ...))
838 arch_construct_function(&fptr, (void *) symaddr,
839 (void *) cmd_call3);
840 printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
841 arg1, arg2, arg3, (void *) symaddr, symbol);
842 printf("Result: %#" PRIxn "\n", fnc(arg1, arg2, arg3));
843 interrupts_restore(ipl);
844 } else {
845 printf("No symbol information available.\n");
846 }
847 return 1;
848}
849
850/** Print detailed description of 'describe' command. */
851void desc_help(void)
852{
853 printf("Syntax: describe command_name\n");
854}
855
856/** Halt the kernel.
857 *
858 * @param argv Argument vector (ignored).
859 *
860 * @return 0 on failure, 1 on success (never returns).
861 */
862int cmd_halt(cmd_arg_t *argv)
863{
864 halt();
865 return 1;
866}
867
868/** Command for printing TLB contents.
869 *
870 * @param argv Not used.
871 *
872 * @return Always returns 1.
873 */
874int cmd_tlb(cmd_arg_t *argv)
875{
876 tlb_print();
877 return 1;
878}
879
880/** Command for printing physical memory configuration.
881 *
882 * @param argv Not used.
883 *
884 * @return Always returns 1.
885 */
886int cmd_physmem(cmd_arg_t *argv)
887{
888 physmem_print();
889 return 1;
890}
891
892/** Write 4 byte value to address */
893int cmd_set4(cmd_arg_t *argv)
894{
895 uintptr_t addr;
896 uint32_t arg1 = argv[1].intval;
897 bool pointer = false;
898 int rc;
899
900 if (((char *) argv->buffer)[0] == '*') {
901 rc = symtab_addr_lookup((char *) argv->buffer + 1, &addr);
902 pointer = true;
903 } else if (((char *) argv->buffer)[0] >= '0' &&
904 ((char *) argv->buffer)[0] <= '9') {
905 uint64_t value;
906 rc = str_uint64((char *) argv->buffer, NULL, 0, true, &value);
907 if (rc == EOK)
908 addr = (uintptr_t) value;
909 } else
910 rc = symtab_addr_lookup((char *) argv->buffer, &addr);
911
912 if (rc == ENOENT)
913 printf("Symbol %s not found.\n", (char *) argv->buffer);
914 else if (rc == EINVAL)
915 printf("Invalid address.\n");
916 else if (rc == EOVERFLOW) {
917 symtab_print_search((char *) argv->buffer);
918 printf("Duplicate symbol (be more specific) or address overflow.\n");
919 } else if (rc == EOK) {
920 if (pointer)
921 addr = *(uintptr_t *) addr;
922 printf("Writing %#" PRIx32" -> %p\n", arg1, (void *) addr);
923 *(uint32_t *) addr = arg1;
924 } else
925 printf("No symbol information available.\n");
926
927 return 1;
928}
929
930/** Command for listings SLAB caches
931 *
932 * @param argv Ignores
933 *
934 * @return Always 1
935 */
936int cmd_slabs(cmd_arg_t *argv)
937{
938 slab_print_list();
939 return 1;
940}
941
942/** Command for dumping sysinfo
943 *
944 * @param argv Ignores
945 *
946 * @return Always 1
947 */
948int cmd_sysinfo(cmd_arg_t *argv)
949{
950 sysinfo_dump(NULL);
951 return 1;
952}
953
954/** Command for listing thread information
955 *
956 * @param argv Ignored
957 *
958 * @return Always 1
959 */
960int cmd_threads(cmd_arg_t *argv)
961{
962 if (str_cmp(flag_buf, "-a") == 0)
963 thread_print_list(true);
964 else if (str_cmp(flag_buf, "") == 0)
965 thread_print_list(false);
966 else
967 printf("Unknown argument \"%s\".\n", flag_buf);
968
969 return 1;
970}
971
972/** Command for listing task information
973 *
974 * @param argv Ignored
975 *
976 * @return Always 1
977 */
978int cmd_tasks(cmd_arg_t *argv)
979{
980 if (str_cmp(flag_buf, "-a") == 0)
981 task_print_list(true);
982 else if (str_cmp(flag_buf, "") == 0)
983 task_print_list(false);
984 else
985 printf("Unknown argument \"%s\".\n", flag_buf);
986
987 return 1;
988}
989
990#ifdef CONFIG_UDEBUG
991
992/** Command for printing thread stack trace
993 *
994 * @param argv Integer argument from cmdline expected
995 *
996 * return Always 1
997 *
998 */
999int cmd_btrace(cmd_arg_t *argv)
1000{
1001 thread_stack_trace(argv[0].intval);
1002 return 1;
1003}
1004
1005#endif /* CONFIG_UDEBUG */
1006
1007/** Command for printing scheduler information
1008 *
1009 * @param argv Ignores
1010 *
1011 * @return Always 1
1012 */
1013int cmd_sched(cmd_arg_t *argv)
1014{
1015 sched_print_list();
1016 return 1;
1017}
1018
1019/** Command for listing memory zones
1020 *
1021 * @param argv Ignored
1022 *
1023 * return Always 1
1024 */
1025int cmd_zones(cmd_arg_t *argv)
1026{
1027 zones_print_list();
1028 return 1;
1029}
1030
1031/** Command for memory zone details
1032 *
1033 * @param argv Integer argument from cmdline expected
1034 *
1035 * return Always 1
1036 */
1037int cmd_zone(cmd_arg_t *argv)
1038{
1039 zone_print_one(argv[0].intval);
1040 return 1;
1041}
1042
1043/** Command for printing task IPC details
1044 *
1045 * @param argv Integer argument from cmdline expected
1046 *
1047 * return Always 1
1048 */
1049int cmd_ipc(cmd_arg_t *argv)
1050{
1051 ipc_print_task(argv[0].intval);
1052 return 1;
1053}
1054
1055/** Command for killing a task
1056 *
1057 * @param argv Integer argument from cmdline expected
1058 *
1059 * return 0 on failure, 1 on success.
1060 */
1061int cmd_kill(cmd_arg_t *argv)
1062{
1063 if (task_kill(argv[0].intval) != EOK)
1064 return 0;
1065
1066 return 1;
1067}
1068
1069/** Command for listing processors.
1070 *
1071 * @param argv Ignored.
1072 *
1073 * return Always 1.
1074 */
1075int cmd_cpus(cmd_arg_t *argv)
1076{
1077 cpu_list();
1078 return 1;
1079}
1080
1081/** Command for printing kernel version.
1082 *
1083 * @param argv Ignored.
1084 *
1085 * return Always 1.
1086 */
1087int cmd_version(cmd_arg_t *argv)
1088{
1089 version_print();
1090 return 1;
1091}
1092
1093/** Command for returning console back to userspace.
1094 *
1095 * @param argv Ignored.
1096 *
1097 * return Always 1.
1098 */
1099int cmd_continue(cmd_arg_t *argv)
1100{
1101 printf("The kernel will now relinquish the console.\n");
1102 release_console();
1103
1104 event_notify_0(EVENT_KCONSOLE);
1105 indev_pop_character(stdin);
1106
1107 return 1;
1108}
1109
1110#ifdef CONFIG_TEST
1111static bool run_test(const test_t *test)
1112{
1113 printf("%s (%s)\n", test->name, test->desc);
1114
1115 /* Update and read thread accounting
1116 for benchmarking */
1117 irq_spinlock_lock(&TASK->lock, true);
1118 uint64_t ucycles0, kcycles0;
1119 task_get_accounting(TASK, &ucycles0, &kcycles0);
1120 irq_spinlock_unlock(&TASK->lock, true);
1121
1122 /* Execute the test */
1123 test_quiet = false;
1124 const char *ret = test->entry();
1125
1126 /* Update and read thread accounting */
1127 uint64_t ucycles1, kcycles1;
1128 irq_spinlock_lock(&TASK->lock, true);
1129 task_get_accounting(TASK, &ucycles1, &kcycles1);
1130 irq_spinlock_unlock(&TASK->lock, true);
1131
1132 uint64_t ucycles, kcycles;
1133 char usuffix, ksuffix;
1134 order_suffix(ucycles1 - ucycles0, &ucycles, &usuffix);
1135 order_suffix(kcycles1 - kcycles0, &kcycles, &ksuffix);
1136
1137 printf("Time: %" PRIu64 "%c user cycles, %" PRIu64 "%c kernel cycles\n",
1138 ucycles, usuffix, kcycles, ksuffix);
1139
1140 if (ret == NULL) {
1141 printf("Test passed\n");
1142 return true;
1143 }
1144
1145 printf("%s\n", ret);
1146 return false;
1147}
1148
1149static bool run_bench(const test_t *test, const uint32_t cnt)
1150{
1151 uint32_t i;
1152 bool ret = true;
1153 uint64_t ucycles, kcycles;
1154 char usuffix, ksuffix;
1155
1156 if (cnt < 1)
1157 return true;
1158
1159 uint64_t *data = (uint64_t *) malloc(sizeof(uint64_t) * cnt, 0);
1160 if (data == NULL) {
1161 printf("Error allocating memory for statistics\n");
1162 return false;
1163 }
1164
1165 for (i = 0; i < cnt; i++) {
1166 printf("%s (%u/%u) ... ", test->name, i + 1, cnt);
1167
1168 /* Update and read thread accounting
1169 for benchmarking */
1170 irq_spinlock_lock(&TASK->lock, true);
1171 uint64_t ucycles0, kcycles0;
1172 task_get_accounting(TASK, &ucycles0, &kcycles0);
1173 irq_spinlock_unlock(&TASK->lock, true);
1174
1175 /* Execute the test */
1176 test_quiet = true;
1177 const char *ret = test->entry();
1178
1179 /* Update and read thread accounting */
1180 irq_spinlock_lock(&TASK->lock, true);
1181 uint64_t ucycles1, kcycles1;
1182 task_get_accounting(TASK, &ucycles1, &kcycles1);
1183 irq_spinlock_unlock(&TASK->lock, true);
1184
1185 if (ret != NULL) {
1186 printf("%s\n", ret);
1187 ret = false;
1188 break;
1189 }
1190
1191 data[i] = ucycles1 - ucycles0 + kcycles1 - kcycles0;
1192 order_suffix(ucycles1 - ucycles0, &ucycles, &usuffix);
1193 order_suffix(kcycles1 - kcycles0, &kcycles, &ksuffix);
1194 printf("OK (%" PRIu64 "%c user cycles, %" PRIu64 "%c kernel cycles)\n",
1195 ucycles, usuffix, kcycles, ksuffix);
1196 }
1197
1198 if (ret) {
1199 printf("\n");
1200
1201 uint64_t sum = 0;
1202
1203 for (i = 0; i < cnt; i++) {
1204 sum += data[i];
1205 }
1206
1207 order_suffix(sum / (uint64_t) cnt, &ucycles, &usuffix);
1208 printf("Average\t\t%" PRIu64 "%c\n", ucycles, usuffix);
1209 }
1210
1211 free(data);
1212
1213 return ret;
1214}
1215
1216static void list_tests(void)
1217{
1218 size_t len = 0;
1219 test_t *test;
1220
1221 for (test = tests; test->name != NULL; test++) {
1222 if (str_length(test->name) > len)
1223 len = str_length(test->name);
1224 }
1225
1226 unsigned int _len = (unsigned int) len;
1227 if ((_len != len) || (((int) _len) < 0)) {
1228 printf("Command length overflow\n");
1229 return;
1230 }
1231
1232 for (test = tests; test->name != NULL; test++)
1233 printf("%-*s %s%s\n", _len, test->name, test->desc,
1234 (test->safe ? "" : " (unsafe)"));
1235
1236 printf("%-*s Run all safe tests\n", _len, "*");
1237}
1238
1239/** Command for listing and running kernel tests
1240 *
1241 * @param argv Argument vector.
1242 *
1243 * return Always 1.
1244 *
1245 */
1246int cmd_test(cmd_arg_t *argv)
1247{
1248 test_t *test;
1249
1250 if (str_cmp((char *) argv->buffer, "*") == 0) {
1251 for (test = tests; test->name != NULL; test++) {
1252 if (test->safe) {
1253 printf("\n");
1254 if (!run_test(test))
1255 break;
1256 }
1257 }
1258 } else if (str_cmp((char *) argv->buffer, "") != 0) {
1259 bool fnd = false;
1260
1261 for (test = tests; test->name != NULL; test++) {
1262 if (str_cmp(test->name, (char *) argv->buffer) == 0) {
1263 fnd = true;
1264 run_test(test);
1265 break;
1266 }
1267 }
1268
1269 if (!fnd)
1270 printf("Unknown test\n");
1271 } else
1272 list_tests();
1273
1274 return 1;
1275}
1276
1277/** Command for returning kernel tests as benchmarks
1278 *
1279 * @param argv Argument vector.
1280 *
1281 * return Always 1.
1282 */
1283int cmd_bench(cmd_arg_t *argv)
1284{
1285 test_t *test;
1286 uint32_t cnt = argv[1].intval;
1287
1288 if (str_cmp((char *) argv->buffer, "*") == 0) {
1289 for (test = tests; test->name != NULL; test++) {
1290 if (test->safe) {
1291 if (!run_bench(test, cnt))
1292 break;
1293 }
1294 }
1295 } else {
1296 bool fnd = false;
1297
1298 for (test = tests; test->name != NULL; test++) {
1299 if (str_cmp(test->name, (char *) argv->buffer) == 0) {
1300 fnd = true;
1301
1302 if (test->safe)
1303 run_bench(test, cnt);
1304 else
1305 printf("Unsafe test\n");
1306
1307 break;
1308 }
1309 }
1310
1311 if (!fnd)
1312 printf("Unknown test\n");
1313 }
1314
1315 return 1;
1316}
1317
1318#endif
1319
1320/** @}
1321 */
Note: See TracBrowser for help on using the repository browser.