source: mainline/kernel/generic/src/console/cmd.c@ 201abde

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

make thread ID 64 bit (task ID is 64 bit already)
cleanup thread syscalls
  • Property mode set to 100644
File size: 21.6 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 <arch/types.h>
49#include <adt/list.h>
50#include <arch.h>
51#include <func.h>
52#include <macros.h>
53#include <debug.h>
54#include <symtab.h>
55#include <cpu.h>
56#include <mm/tlb.h>
57#include <arch/mm/tlb.h>
58#include <mm/frame.h>
59#include <main/version.h>
60#include <mm/slab.h>
61#include <proc/scheduler.h>
62#include <proc/thread.h>
63#include <proc/task.h>
64#include <ipc/ipc.h>
65#include <ipc/irq.h>
66
67#ifdef CONFIG_TEST
68#include <test.h>
69#endif
70
71/* Data and methods for 'help' command. */
72static int cmd_help(cmd_arg_t *argv);
73static cmd_info_t help_info = {
74 .name = "help",
75 .description = "List of supported commands.",
76 .func = cmd_help,
77 .argc = 0
78};
79
80static cmd_info_t exit_info = {
81 .name = "exit",
82 .description = "Exit kconsole",
83 .argc = 0
84};
85
86static int cmd_continue(cmd_arg_t *argv);
87static cmd_info_t continue_info = {
88 .name = "continue",
89 .description = "Return console back to userspace.",
90 .func = cmd_continue,
91 .argc = 0
92};
93
94#ifdef CONFIG_TEST
95static int cmd_tests(cmd_arg_t *argv);
96static cmd_info_t tests_info = {
97 .name = "tests",
98 .description = "Print available kernel tests.",
99 .func = cmd_tests,
100 .argc = 0
101};
102
103static char test_buf[MAX_CMDLINE + 1];
104static int cmd_test(cmd_arg_t *argv);
105static cmd_arg_t test_argv[] = {
106 {
107 .type = ARG_TYPE_STRING,
108 .buffer = test_buf,
109 .len = sizeof(test_buf)
110 }
111};
112static cmd_info_t test_info = {
113 .name = "test",
114 .description = "Run kernel test.",
115 .func = cmd_test,
116 .argc = 1,
117 .argv = test_argv
118};
119
120static int cmd_bench(cmd_arg_t *argv);
121static cmd_arg_t bench_argv[] = {
122 {
123 .type = ARG_TYPE_STRING,
124 .buffer = test_buf,
125 .len = sizeof(test_buf)
126 },
127 {
128 .type = ARG_TYPE_INT,
129 }
130};
131static cmd_info_t bench_info = {
132 .name = "bench",
133 .description = "Run kernel test as benchmark.",
134 .func = cmd_bench,
135 .argc = 2,
136 .argv = bench_argv
137};
138#endif
139
140/* Data and methods for 'description' command. */
141static int cmd_desc(cmd_arg_t *argv);
142static void desc_help(void);
143static char desc_buf[MAX_CMDLINE+1];
144static cmd_arg_t desc_argv = {
145 .type = ARG_TYPE_STRING,
146 .buffer = desc_buf,
147 .len = sizeof(desc_buf)
148};
149static cmd_info_t desc_info = {
150 .name = "describe",
151 .description = "Describe specified command.",
152 .help = desc_help,
153 .func = cmd_desc,
154 .argc = 1,
155 .argv = &desc_argv
156};
157
158/* Data and methods for 'symaddr' command. */
159static int cmd_symaddr(cmd_arg_t *argv);
160static char symaddr_buf[MAX_CMDLINE+1];
161static cmd_arg_t symaddr_argv = {
162 .type = ARG_TYPE_STRING,
163 .buffer = symaddr_buf,
164 .len = sizeof(symaddr_buf)
165};
166static cmd_info_t symaddr_info = {
167 .name = "symaddr",
168 .description = "Return symbol address.",
169 .func = cmd_symaddr,
170 .argc = 1,
171 .argv = &symaddr_argv
172};
173
174static char set_buf[MAX_CMDLINE+1];
175static int cmd_set4(cmd_arg_t *argv);
176static cmd_arg_t set4_argv[] = {
177 {
178 .type = ARG_TYPE_STRING,
179 .buffer = set_buf,
180 .len = sizeof(set_buf)
181 },
182 {
183 .type = ARG_TYPE_INT
184 }
185};
186static cmd_info_t set4_info = {
187 .name = "set4",
188 .description = "set <dest_addr> <value> - 4byte version",
189 .func = cmd_set4,
190 .argc = 2,
191 .argv = set4_argv
192};
193
194/* Data and methods for 'call0' command. */
195static char call0_buf[MAX_CMDLINE+1];
196static char carg1_buf[MAX_CMDLINE+1];
197static char carg2_buf[MAX_CMDLINE+1];
198static char carg3_buf[MAX_CMDLINE+1];
199
200static int cmd_call0(cmd_arg_t *argv);
201static cmd_arg_t call0_argv = {
202 .type = ARG_TYPE_STRING,
203 .buffer = call0_buf,
204 .len = sizeof(call0_buf)
205};
206static cmd_info_t call0_info = {
207 .name = "call0",
208 .description = "call0 <function> -> call function().",
209 .func = cmd_call0,
210 .argc = 1,
211 .argv = &call0_argv
212};
213
214/* Data and methods for 'call1' command. */
215static int cmd_call1(cmd_arg_t *argv);
216static cmd_arg_t call1_argv[] = {
217 {
218 .type = ARG_TYPE_STRING,
219 .buffer = call0_buf,
220 .len = sizeof(call0_buf)
221 },
222 {
223 .type = ARG_TYPE_VAR,
224 .buffer = carg1_buf,
225 .len = sizeof(carg1_buf)
226 }
227};
228static cmd_info_t call1_info = {
229 .name = "call1",
230 .description = "call1 <function> <arg1> -> call function(arg1).",
231 .func = cmd_call1,
232 .argc = 2,
233 .argv = call1_argv
234};
235
236/* Data and methods for 'call2' command. */
237static int cmd_call2(cmd_arg_t *argv);
238static cmd_arg_t call2_argv[] = {
239 {
240 .type = ARG_TYPE_STRING,
241 .buffer = call0_buf,
242 .len = sizeof(call0_buf)
243 },
244 {
245 .type = ARG_TYPE_VAR,
246 .buffer = carg1_buf,
247 .len = sizeof(carg1_buf)
248 },
249 {
250 .type = ARG_TYPE_VAR,
251 .buffer = carg2_buf,
252 .len = sizeof(carg2_buf)
253 }
254};
255static cmd_info_t call2_info = {
256 .name = "call2",
257 .description = "call2 <function> <arg1> <arg2> -> call function(arg1,arg2).",
258 .func = cmd_call2,
259 .argc = 3,
260 .argv = call2_argv
261};
262
263/* Data and methods for 'call3' command. */
264static int cmd_call3(cmd_arg_t *argv);
265static cmd_arg_t call3_argv[] = {
266 {
267 .type = ARG_TYPE_STRING,
268 .buffer = call0_buf,
269 .len = sizeof(call0_buf)
270 },
271 {
272 .type = ARG_TYPE_VAR,
273 .buffer = carg1_buf,
274 .len = sizeof(carg1_buf)
275 },
276 {
277 .type = ARG_TYPE_VAR,
278 .buffer = carg2_buf,
279 .len = sizeof(carg2_buf)
280 },
281 {
282 .type = ARG_TYPE_VAR,
283 .buffer = carg3_buf,
284 .len = sizeof(carg3_buf)
285 }
286
287};
288static cmd_info_t call3_info = {
289 .name = "call3",
290 .description = "call3 <function> <arg1> <arg2> <arg3> -> call function(arg1,arg2,arg3).",
291 .func = cmd_call3,
292 .argc = 4,
293 .argv = call3_argv
294};
295
296/* Data and methods for 'halt' command. */
297static int cmd_halt(cmd_arg_t *argv);
298static cmd_info_t halt_info = {
299 .name = "halt",
300 .description = "Halt the kernel.",
301 .func = cmd_halt,
302 .argc = 0
303};
304
305/* Data and methods for 'tlb' command. */
306static int cmd_tlb(cmd_arg_t *argv);
307cmd_info_t tlb_info = {
308 .name = "tlb",
309 .description = "Print TLB of current processor.",
310 .help = NULL,
311 .func = cmd_tlb,
312 .argc = 0,
313 .argv = NULL
314};
315
316static int cmd_threads(cmd_arg_t *argv);
317static cmd_info_t threads_info = {
318 .name = "threads",
319 .description = "List all threads.",
320 .func = cmd_threads,
321 .argc = 0
322};
323
324static int cmd_tasks(cmd_arg_t *argv);
325static cmd_info_t tasks_info = {
326 .name = "tasks",
327 .description = "List all tasks.",
328 .func = cmd_tasks,
329 .argc = 0
330};
331
332
333static int cmd_sched(cmd_arg_t *argv);
334static cmd_info_t sched_info = {
335 .name = "scheduler",
336 .description = "List all scheduler information.",
337 .func = cmd_sched,
338 .argc = 0
339};
340
341static int cmd_slabs(cmd_arg_t *argv);
342static cmd_info_t slabs_info = {
343 .name = "slabs",
344 .description = "List slab caches.",
345 .func = cmd_slabs,
346 .argc = 0
347};
348
349/* Data and methods for 'zones' command */
350static int cmd_zones(cmd_arg_t *argv);
351static cmd_info_t zones_info = {
352 .name = "zones",
353 .description = "List of memory zones.",
354 .func = cmd_zones,
355 .argc = 0
356};
357
358/* Data and methods for 'ipc_task' command */
359static int cmd_ipc_task(cmd_arg_t *argv);
360static cmd_arg_t ipc_task_argv = {
361 .type = ARG_TYPE_INT,
362};
363static cmd_info_t ipc_task_info = {
364 .name = "ipc_task",
365 .description = "ipc_task <taskid> Show IPC information of given task.",
366 .func = cmd_ipc_task,
367 .argc = 1,
368 .argv = &ipc_task_argv
369};
370
371/* Data and methods for 'zone' command */
372static int cmd_zone(cmd_arg_t *argv);
373static cmd_arg_t zone_argv = {
374 .type = ARG_TYPE_INT,
375};
376
377static cmd_info_t zone_info = {
378 .name = "zone",
379 .description = "Show memory zone structure.",
380 .func = cmd_zone,
381 .argc = 1,
382 .argv = &zone_argv
383};
384
385/* Data and methods for 'cpus' command. */
386static int cmd_cpus(cmd_arg_t *argv);
387cmd_info_t cpus_info = {
388 .name = "cpus",
389 .description = "List all processors.",
390 .help = NULL,
391 .func = cmd_cpus,
392 .argc = 0,
393 .argv = NULL
394};
395
396/* Data and methods for 'version' command. */
397static int cmd_version(cmd_arg_t *argv);
398cmd_info_t version_info = {
399 .name = "version",
400 .description = "Print version information.",
401 .help = NULL,
402 .func = cmd_version,
403 .argc = 0,
404 .argv = NULL
405};
406
407static cmd_info_t *basic_commands[] = {
408 &call0_info,
409 &call1_info,
410 &call2_info,
411 &call3_info,
412 &continue_info,
413 &cpus_info,
414 &desc_info,
415 &exit_info,
416 &halt_info,
417 &help_info,
418 &ipc_task_info,
419 &set4_info,
420 &slabs_info,
421 &symaddr_info,
422 &sched_info,
423 &threads_info,
424 &tasks_info,
425 &tlb_info,
426 &version_info,
427 &zones_info,
428 &zone_info,
429#ifdef CONFIG_TEST
430 &tests_info,
431 &test_info,
432 &bench_info,
433#endif
434 NULL
435};
436
437
438/** Initialize command info structure.
439 *
440 * @param cmd Command info structure.
441 *
442 */
443void cmd_initialize(cmd_info_t *cmd)
444{
445 spinlock_initialize(&cmd->lock, "cmd");
446 link_initialize(&cmd->link);
447}
448
449/** Initialize and register commands. */
450void cmd_init(void)
451{
452 int i;
453
454 for (i=0;basic_commands[i]; i++) {
455 cmd_initialize(basic_commands[i]);
456 if (!cmd_register(basic_commands[i]))
457 panic("could not register command %s\n",
458 basic_commands[i]->name);
459 }
460}
461
462
463/** List supported commands.
464 *
465 * @param argv Argument vector.
466 *
467 * @return 0 on failure, 1 on success.
468 */
469int cmd_help(cmd_arg_t *argv)
470{
471 link_t *cur;
472
473 spinlock_lock(&cmd_lock);
474
475 for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
476 cmd_info_t *hlp;
477
478 hlp = list_get_instance(cur, cmd_info_t, link);
479 spinlock_lock(&hlp->lock);
480
481 printf("%s - %s\n", hlp->name, hlp->description);
482
483 spinlock_unlock(&hlp->lock);
484 }
485
486 spinlock_unlock(&cmd_lock);
487
488 return 1;
489}
490
491/** Describe specified command.
492 *
493 * @param argv Argument vector.
494 *
495 * @return 0 on failure, 1 on success.
496 */
497int cmd_desc(cmd_arg_t *argv)
498{
499 link_t *cur;
500
501 spinlock_lock(&cmd_lock);
502
503 for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
504 cmd_info_t *hlp;
505
506 hlp = list_get_instance(cur, cmd_info_t, link);
507 spinlock_lock(&hlp->lock);
508
509 if (strncmp(hlp->name, (const char *) argv->buffer, strlen(hlp->name)) == 0) {
510 printf("%s - %s\n", hlp->name, hlp->description);
511 if (hlp->help)
512 hlp->help();
513 spinlock_unlock(&hlp->lock);
514 break;
515 }
516
517 spinlock_unlock(&hlp->lock);
518 }
519
520 spinlock_unlock(&cmd_lock);
521
522 return 1;
523}
524
525/** Search symbol table */
526int cmd_symaddr(cmd_arg_t *argv)
527{
528 symtab_print_search((char *) argv->buffer);
529
530 return 1;
531}
532
533/** Call function with zero parameters */
534int cmd_call0(cmd_arg_t *argv)
535{
536 uintptr_t symaddr;
537 char *symbol;
538 unative_t (*f)(void);
539#ifdef ia64
540 struct {
541 unative_t f;
542 unative_t gp;
543 }fptr;
544#endif
545
546 symaddr = get_symbol_addr((char *) argv->buffer);
547 if (!symaddr)
548 printf("Symbol %s not found.\n", argv->buffer);
549 else if (symaddr == (uintptr_t) -1) {
550 symtab_print_search((char *) argv->buffer);
551 printf("Duplicate symbol, be more specific.\n");
552 } else {
553 symbol = get_symtab_entry(symaddr);
554 printf("Calling f(): %.*p: %s\n", sizeof(uintptr_t) * 2, symaddr, symbol);
555#ifdef ia64
556 fptr.f = symaddr;
557 fptr.gp = ((unative_t *)cmd_call2)[1];
558 f = (unative_t (*)(void)) &fptr;
559#else
560 f = (unative_t (*)(void)) symaddr;
561#endif
562 printf("Result: %#zx\n", f());
563 }
564
565 return 1;
566}
567
568/** Call function with one parameter */
569int cmd_call1(cmd_arg_t *argv)
570{
571 uintptr_t symaddr;
572 char *symbol;
573 unative_t (*f)(unative_t,...);
574 unative_t arg1 = argv[1].intval;
575#ifdef ia64
576 struct {
577 unative_t f;
578 unative_t gp;
579 }fptr;
580#endif
581
582 symaddr = get_symbol_addr((char *) argv->buffer);
583 if (!symaddr)
584 printf("Symbol %s not found.\n", argv->buffer);
585 else if (symaddr == (uintptr_t) -1) {
586 symtab_print_search((char *) argv->buffer);
587 printf("Duplicate symbol, be more specific.\n");
588 } else {
589 symbol = get_symtab_entry(symaddr);
590
591 printf("Calling f(%#zx): %.*p: %s\n", arg1, sizeof(uintptr_t) * 2, symaddr, symbol);
592#ifdef ia64
593 fptr.f = symaddr;
594 fptr.gp = ((unative_t *)cmd_call2)[1];
595 f = (unative_t (*)(unative_t,...)) &fptr;
596#else
597 f = (unative_t (*)(unative_t,...)) symaddr;
598#endif
599 printf("Result: %#zx\n", f(arg1));
600 }
601
602 return 1;
603}
604
605/** Call function with two parameters */
606int cmd_call2(cmd_arg_t *argv)
607{
608 uintptr_t symaddr;
609 char *symbol;
610 unative_t (*f)(unative_t,unative_t,...);
611 unative_t arg1 = argv[1].intval;
612 unative_t arg2 = argv[2].intval;
613#ifdef ia64
614 struct {
615 unative_t f;
616 unative_t gp;
617 }fptr;
618#endif
619
620 symaddr = get_symbol_addr((char *) argv->buffer);
621 if (!symaddr)
622 printf("Symbol %s not found.\n", argv->buffer);
623 else if (symaddr == (uintptr_t) -1) {
624 symtab_print_search((char *) argv->buffer);
625 printf("Duplicate symbol, be more specific.\n");
626 } else {
627 symbol = get_symtab_entry(symaddr);
628 printf("Calling f(0x%zx,0x%zx): %.*p: %s\n",
629 arg1, arg2, sizeof(uintptr_t) * 2, symaddr, symbol);
630#ifdef ia64
631 fptr.f = symaddr;
632 fptr.gp = ((unative_t *)cmd_call2)[1];
633 f = (unative_t (*)(unative_t,unative_t,...)) &fptr;
634#else
635 f = (unative_t (*)(unative_t,unative_t,...)) symaddr;
636#endif
637 printf("Result: %#zx\n", f(arg1, arg2));
638 }
639
640 return 1;
641}
642
643/** Call function with three parameters */
644int cmd_call3(cmd_arg_t *argv)
645{
646 uintptr_t symaddr;
647 char *symbol;
648 unative_t (*f)(unative_t,unative_t,unative_t,...);
649 unative_t arg1 = argv[1].intval;
650 unative_t arg2 = argv[2].intval;
651 unative_t arg3 = argv[3].intval;
652#ifdef ia64
653 struct {
654 unative_t f;
655 unative_t gp;
656 }fptr;
657#endif
658
659 symaddr = get_symbol_addr((char *) argv->buffer);
660 if (!symaddr)
661 printf("Symbol %s not found.\n", argv->buffer);
662 else if (symaddr == (uintptr_t) -1) {
663 symtab_print_search((char *) argv->buffer);
664 printf("Duplicate symbol, be more specific.\n");
665 } else {
666 symbol = get_symtab_entry(symaddr);
667 printf("Calling f(0x%zx,0x%zx, 0x%zx): %.*p: %s\n",
668 arg1, arg2, arg3, sizeof(uintptr_t) * 2, symaddr, symbol);
669#ifdef ia64
670 fptr.f = symaddr;
671 fptr.gp = ((unative_t *)cmd_call2)[1];
672 f = (unative_t (*)(unative_t,unative_t,unative_t,...)) &fptr;
673#else
674 f = (unative_t (*)(unative_t,unative_t,unative_t,...)) symaddr;
675#endif
676 printf("Result: %#zx\n", f(arg1, arg2, arg3));
677 }
678
679 return 1;
680}
681
682
683/** Print detailed description of 'describe' command. */
684void desc_help(void)
685{
686 printf("Syntax: describe command_name\n");
687}
688
689/** Halt the kernel.
690 *
691 * @param argv Argument vector (ignored).
692 *
693 * @return 0 on failure, 1 on success (never returns).
694 */
695int cmd_halt(cmd_arg_t *argv)
696{
697 halt();
698 return 1;
699}
700
701/** Command for printing TLB contents.
702 *
703 * @param argv Not used.
704 *
705 * @return Always returns 1.
706 */
707int cmd_tlb(cmd_arg_t *argv)
708{
709 tlb_print();
710 return 1;
711}
712
713/** Write 4 byte value to address */
714int cmd_set4(cmd_arg_t *argv)
715{
716 uint32_t *addr;
717 uint32_t arg1 = argv[1].intval;
718 bool pointer = false;
719
720 if (((char *)argv->buffer)[0] == '*') {
721 addr = (uint32_t *) get_symbol_addr((char *) argv->buffer + 1);
722 pointer = true;
723 } else if (((char *) argv->buffer)[0] >= '0' &&
724 ((char *)argv->buffer)[0] <= '9')
725 addr = (uint32_t *)atoi((char *)argv->buffer);
726 else
727 addr = (uint32_t *)get_symbol_addr((char *) argv->buffer);
728
729 if (!addr)
730 printf("Symbol %s not found.\n", argv->buffer);
731 else if (addr == (uint32_t *) -1) {
732 symtab_print_search((char *) argv->buffer);
733 printf("Duplicate symbol, be more specific.\n");
734 } else {
735 if (pointer)
736 addr = (uint32_t *)(*(unative_t *)addr);
737 printf("Writing 0x%x -> %.*p\n", arg1, sizeof(uintptr_t) * 2, addr);
738 *addr = arg1;
739
740 }
741
742 return 1;
743}
744
745/** Command for listings SLAB caches
746 *
747 * @param argv Ignores
748 *
749 * @return Always 1
750 */
751int cmd_slabs(cmd_arg_t * argv) {
752 slab_print_list();
753 return 1;
754}
755
756
757/** Command for listings Thread information
758 *
759 * @param argv Ignores
760 *
761 * @return Always 1
762 */
763int cmd_threads(cmd_arg_t * argv) {
764 thread_print_list();
765 return 1;
766}
767
768/** Command for listings Task information
769 *
770 * @param argv Ignores
771 *
772 * @return Always 1
773 */
774int cmd_tasks(cmd_arg_t * argv) {
775 task_print_list();
776 return 1;
777}
778
779/** Command for listings Thread information
780 *
781 * @param argv Ignores
782 *
783 * @return Always 1
784 */
785int cmd_sched(cmd_arg_t * argv) {
786 sched_print_list();
787 return 1;
788}
789
790/** Command for listing memory zones
791 *
792 * @param argv Ignored
793 *
794 * return Always 1
795 */
796int cmd_zones(cmd_arg_t * argv) {
797 zone_print_list();
798 return 1;
799}
800
801/** Command for memory zone details
802 *
803 * @param argv Integer argument from cmdline expected
804 *
805 * return Always 1
806 */
807int cmd_zone(cmd_arg_t * argv) {
808 zone_print_one(argv[0].intval);
809 return 1;
810}
811
812/** Command for printing task ipc details
813 *
814 * @param argv Integer argument from cmdline expected
815 *
816 * return Always 1
817 */
818int cmd_ipc_task(cmd_arg_t * argv) {
819 ipc_print_task(argv[0].intval);
820 return 1;
821}
822
823
824/** Command for listing processors.
825 *
826 * @param argv Ignored.
827 *
828 * return Always 1.
829 */
830int cmd_cpus(cmd_arg_t *argv)
831{
832 cpu_list();
833 return 1;
834}
835
836/** Command for printing kernel version.
837 *
838 * @param argv Ignored.
839 *
840 * return Always 1.
841 */
842int cmd_version(cmd_arg_t *argv)
843{
844 version_print();
845 return 1;
846}
847
848/** Command for returning console back to userspace.
849 *
850 * @param argv Ignored.
851 *
852 * return Always 1.
853 */
854int cmd_continue(cmd_arg_t *argv)
855{
856 printf("The kernel will now relinquish the console.\n");
857 printf("Use userspace controls to redraw the screen.\n");
858 arch_release_console();
859 return 1;
860}
861
862#ifdef CONFIG_TEST
863/** Command for printing kernel tests list.
864 *
865 * @param argv Ignored.
866 *
867 * return Always 1.
868 */
869int cmd_tests(cmd_arg_t *argv)
870{
871 test_t *test;
872
873 for (test = tests; test->name != NULL; test++)
874 printf("%s\t\t%s%s\n", test->name, test->desc, (test->safe ? "" : " (unsafe)"));
875
876 printf("*\t\tRun all safe tests\n");
877 return 1;
878}
879
880static bool run_test(const test_t *test)
881{
882 printf("%s\t\t%s\n", test->name, test->desc);
883
884 /* Update and read thread accounting
885 for benchmarking */
886 ipl_t ipl = interrupts_disable();
887 spinlock_lock(&TASK->lock);
888 uint64_t t0 = task_get_accounting(TASK);
889 spinlock_unlock(&TASK->lock);
890 interrupts_restore(ipl);
891
892 /* Execute the test */
893 char * ret = test->entry(false);
894
895 /* Update and read thread accounting */
896 ipl = interrupts_disable();
897 spinlock_lock(&TASK->lock);
898 uint64_t dt = task_get_accounting(TASK) - t0;
899 spinlock_unlock(&TASK->lock);
900 interrupts_restore(ipl);
901
902 uint64_t cycles;
903 char suffix;
904 order(dt, &cycles, &suffix);
905
906 printf("Time: %llu%c cycles\n", cycles, suffix);
907
908 if (ret == NULL) {
909 printf("Test passed\n");
910 return true;
911 }
912
913 printf("%s\n", ret);
914 return false;
915}
916
917static bool run_bench(const test_t *test, const uint32_t cnt)
918{
919 uint32_t i;
920 bool ret = true;
921 uint64_t cycles;
922 char suffix;
923
924 if (cnt < 1)
925 return true;
926
927 uint64_t *data = (uint64_t *) malloc(sizeof(uint64_t) * cnt, 0);
928 if (data == NULL) {
929 printf("Error allocating memory for statistics\n");
930 return false;
931 }
932
933 for (i = 0; i < cnt; i++) {
934 printf("%s (%d/%d) ... ", test->name, i + 1, cnt);
935
936 /* Update and read thread accounting
937 for benchmarking */
938 ipl_t ipl = interrupts_disable();
939 spinlock_lock(&TASK->lock);
940 uint64_t t0 = task_get_accounting(TASK);
941 spinlock_unlock(&TASK->lock);
942 interrupts_restore(ipl);
943
944 /* Execute the test */
945 char * ret = test->entry(true);
946
947 /* Update and read thread accounting */
948 ipl = interrupts_disable();
949 spinlock_lock(&TASK->lock);
950 uint64_t dt = task_get_accounting(TASK) - t0;
951 spinlock_unlock(&TASK->lock);
952 interrupts_restore(ipl);
953
954 if (ret != NULL) {
955 printf("%s\n", ret);
956 ret = false;
957 break;
958 }
959
960 data[i] = dt;
961 order(dt, &cycles, &suffix);
962 printf("OK (%llu%c cycles)\n", cycles, suffix);
963 }
964
965 if (ret) {
966 printf("\n");
967
968 uint64_t sum = 0;
969
970 for (i = 0; i < cnt; i++) {
971 sum += data[i];
972 }
973
974 order(sum / (uint64_t) cnt, &cycles, &suffix);
975 printf("Average\t\t%llu%c\n", cycles, suffix);
976 }
977
978 free(data);
979
980 return ret;
981}
982
983/** Command for returning kernel tests
984 *
985 * @param argv Argument vector.
986 *
987 * return Always 1.
988 */
989int cmd_test(cmd_arg_t *argv)
990{
991 test_t *test;
992
993 if (strcmp((char *) argv->buffer, "*") == 0) {
994 for (test = tests; test->name != NULL; test++) {
995 if (test->safe) {
996 printf("\n");
997 if (!run_test(test))
998 break;
999 }
1000 }
1001 } else {
1002 bool fnd = false;
1003
1004 for (test = tests; test->name != NULL; test++) {
1005 if (strcmp(test->name, (char *) argv->buffer) == 0) {
1006 fnd = true;
1007 run_test(test);
1008 break;
1009 }
1010 }
1011
1012 if (!fnd)
1013 printf("Unknown test\n");
1014 }
1015
1016 return 1;
1017}
1018
1019/** Command for returning kernel tests as benchmarks
1020 *
1021 * @param argv Argument vector.
1022 *
1023 * return Always 1.
1024 */
1025int cmd_bench(cmd_arg_t *argv)
1026{
1027 test_t *test;
1028 uint32_t cnt = argv[1].intval;
1029
1030 bool fnd = false;
1031
1032 for (test = tests; test->name != NULL; test++) {
1033 if (strcmp(test->name, (char *) argv->buffer) == 0) {
1034 fnd = true;
1035
1036 if (test->safe)
1037 run_bench(test, cnt);
1038 else
1039 printf("Unsafe test\n");
1040
1041 break;
1042 }
1043 }
1044
1045 if (!fnd)
1046 printf("Unknown test\n");
1047
1048 return 1;
1049}
1050
1051#endif
1052
1053/** @}
1054 */
Note: See TracBrowser for help on using the repository browser.