WebSVN – HelenOS-historic – Diff – /kernel/trunk/generic/src/console/cmd.c


/*
 * Copyright (C) 2005 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/**
 * @file    cmd.c
 * @brief   Kernel console command wrappers.
 *
 * This file is meant to contain all wrapper functions for
 * all kconsole commands. The point is in separating
 * kconsole specific wrappers from kconsole-unaware functions
 * from other subsystems.
 */
 
#include <console/cmd.h>
#include <console/console.h>
#include <console/kconsole.h>
#include <print.h>
#include <panic.h>
#include <typedefs.h>
#include <arch/types.h>
#include <adt/list.h>
#include <arch.h>
#include <func.h>
#include <macros.h>
#include <debug.h>
#include <symtab.h>
#include <cpu.h>
#include <mm/tlb.h>
#include <arch/mm/tlb.h>
#include <mm/frame.h>
#include <main/version.h>
#include <mm/slab.h>
#include <proc/scheduler.h>
#include <proc/thread.h>
#include <proc/task.h>
#include <ipc/ipc.h>
 
/** Data and methods for 'help' command. */
static int cmd_help(cmd_arg_t *argv);
static cmd_info_t help_info = {
    .name = "help",
    .description = "List of supported commands.",
    .func = cmd_help,
    .argc = 0
};
 
static cmd_info_t exit_info = {
    .name = "exit",
    .description ="Exit kconsole",
    .argc = 0
};
 
static int cmd_continue(cmd_arg_t *argv);
static cmd_info_t continue_info = {
    .name = "continue",
    .description ="Return console back to userspace",
    .func = cmd_continue,
    .argc = 0
};
 
/** Data and methods for 'description' command. */
static int cmd_desc(cmd_arg_t *argv);
static void desc_help(void);
static char desc_buf[MAX_CMDLINE+1];
static cmd_arg_t desc_argv = {
    .type = ARG_TYPE_STRING,
    .buffer = desc_buf,
    .len = sizeof(desc_buf)
};
static cmd_info_t desc_info = {
    .name = "describe",
    .description = "Describe specified command.",
    .help = desc_help,
    .func = cmd_desc,
    .argc = 1,
    .argv = &desc_argv
};
 
/** Data and methods for 'symaddr' command. */
static int cmd_symaddr(cmd_arg_t *argv);
static char symaddr_buf[MAX_CMDLINE+1];
static cmd_arg_t symaddr_argv = {
    .type = ARG_TYPE_STRING,
    .buffer = symaddr_buf,
    .len = sizeof(symaddr_buf)
};
static cmd_info_t symaddr_info = {
    .name = "symaddr",
    .description = "Return symbol address.",
    .func = cmd_symaddr,
    .argc = 1,
    .argv = &symaddr_argv
};
 
static char set_buf[MAX_CMDLINE+1];
static int cmd_set4(cmd_arg_t *argv);
static cmd_arg_t set4_argv[] = {
    {
        .type = ARG_TYPE_STRING,
        .buffer = set_buf,
        .len = sizeof(set_buf)
    },
    {
        .type = ARG_TYPE_INT
    }
};
static cmd_info_t set4_info = {
    .name = "set4",
    .description = "set <dest_addr> <value> - 4byte version",
    .func = cmd_set4,
    .argc = 2,
    .argv = set4_argv
};
 
/** Data and methods for 'call0' command. */
static char call0_buf[MAX_CMDLINE+1];
static char carg1_buf[MAX_CMDLINE+1];
static char carg2_buf[MAX_CMDLINE+1];
static char carg3_buf[MAX_CMDLINE+1];
 
static int cmd_call0(cmd_arg_t *argv);
static cmd_arg_t call0_argv = {
    .type = ARG_TYPE_STRING,
    .buffer = call0_buf,
    .len = sizeof(call0_buf)
};
static cmd_info_t call0_info = {
    .name = "call0",
    .description = "call0 <function> -> call function().",
    .func = cmd_call0,
    .argc = 1,
    .argv = &call0_argv
};
 
/** Data and methods for 'call1' command. */
static int cmd_call1(cmd_arg_t *argv);
static cmd_arg_t call1_argv[] = {
    {
        .type = ARG_TYPE_STRING,
        .buffer = call0_buf,
        .len = sizeof(call0_buf)
    },
    {
        .type = ARG_TYPE_VAR,
        .buffer = carg1_buf,
        .len = sizeof(carg1_buf)
    }
};
static cmd_info_t call1_info = {
    .name = "call1",
    .description = "call1 <function> <arg1> -> call function(arg1).",
    .func = cmd_call1,
    .argc = 2,
    .argv = call1_argv
};
 
/** Data and methods for 'call2' command. */
static int cmd_call2(cmd_arg_t *argv);
static cmd_arg_t call2_argv[] = {
    {
        .type = ARG_TYPE_STRING,
        .buffer = call0_buf,
        .len = sizeof(call0_buf)
    },
    {
        .type = ARG_TYPE_VAR,
        .buffer = carg1_buf,
        .len = sizeof(carg1_buf)
    },
    {
        .type = ARG_TYPE_VAR,
        .buffer = carg2_buf,
        .len = sizeof(carg2_buf)
    }
};
static cmd_info_t call2_info = {
    .name = "call2",
    .description = "call2 <function> <arg1> <arg2> -> call function(arg1,arg2).",
    .func = cmd_call2,
    .argc = 3,
    .argv = call2_argv
};
 
/** Data and methods for 'call3' command. */
static int cmd_call3(cmd_arg_t *argv);
static cmd_arg_t call3_argv[] = {
    {
        .type = ARG_TYPE_STRING,
        .buffer = call0_buf,
        .len = sizeof(call0_buf)
    },
    {
        .type = ARG_TYPE_VAR,
        .buffer = carg1_buf,
        .len = sizeof(carg1_buf)
    },
    {
        .type = ARG_TYPE_VAR,
        .buffer = carg2_buf,
        .len = sizeof(carg2_buf)
    },
    {
        .type = ARG_TYPE_VAR,
        .buffer = carg3_buf,
        .len = sizeof(carg3_buf)
    }
 
};
static cmd_info_t call3_info = {
    .name = "call3",
    .description = "call3 <function> <arg1> <arg2> <arg3> -> call function(arg1,arg2,arg3).",
    .func = cmd_call3,
    .argc = 4,
    .argv = call3_argv
};
 
/** Data and methods for 'halt' command. */
static int cmd_halt(cmd_arg_t *argv);
static cmd_info_t halt_info = {
    .name = "halt",
    .description = "Halt the kernel.",
    .func = cmd_halt,
    .argc = 0
};
 
/** Data and methods for 'tlb' command. */
static int cmd_tlb(cmd_arg_t *argv);
cmd_info_t tlb_info = {
    .name = "tlb",
    .description = "Print TLB of current processor.",
    .help = NULL,
    .func = cmd_tlb,
    .argc = 0,
    .argv = NULL
};
 
static int cmd_threads(cmd_arg_t *argv);
static cmd_info_t threads_info = {
    .name = "threads",
    .description = "List all threads",
    .func = cmd_threads,
    .argc = 0
};
 
static int cmd_tasks(cmd_arg_t *argv);
static cmd_info_t tasks_info = {
    .name = "tasks",
    .description = "List all tasks",
    .func = cmd_tasks,
    .argc = 0
};
 
 
static int cmd_sched(cmd_arg_t *argv);
static cmd_info_t sched_info = {
    .name = "scheduler",
    .description = "List all scheduler information",
    .func = cmd_sched,
    .argc = 0
};
 
static int cmd_slabs(cmd_arg_t *argv);
static cmd_info_t slabs_info = {
    .name = "slabs",
    .description = "List SLAB caches.",
    .func = cmd_slabs,
    .argc = 0
};
 
/** Data and methods for 'zones' command */
static int cmd_zones(cmd_arg_t *argv);
static cmd_info_t zones_info = {
    .name = "zones",
    .description = "List of memory zones.",
    .func = cmd_zones,
    .argc = 0
};
 
/** Data and methods for 'ipc_task' command */
static int cmd_ipc_task(cmd_arg_t *argv);
static cmd_arg_t ipc_task_argv = {
    .type = ARG_TYPE_INT,
};
static cmd_info_t ipc_task_info = {
    .name = "ipc_task",
    .description = "Show memory zone structure.",
    .func = cmd_ipc_task,
    .argc = 1,
    .argv = &ipc_task_argv
};
 
/** Data and methods for 'zone' command */
static int cmd_zone(cmd_arg_t *argv);
static cmd_arg_t zone_argv = {
    .type = ARG_TYPE_INT,
};
 
static cmd_info_t zone_info = {
    .name = "zone",
    .description = "Show memory zone structure.",
    .func = cmd_zone,
    .argc = 1,
    .argv = &zone_argv
};
 
/** Data and methods for 'cpus' command. */
static int cmd_cpus(cmd_arg_t *argv);
cmd_info_t cpus_info = {
    .name = "cpus",
    .description = "List all processors.",
    .help = NULL,
    .func = cmd_cpus,
    .argc = 0,
    .argv = NULL
};
 
/** Data and methods for 'version' command. */
static int cmd_version(cmd_arg_t *argv);
cmd_info_t version_info = {
    .name = "version",
    .description = "Print version information.",
    .help = NULL,
    .func = cmd_version,
    .argc = 0,
    .argv = NULL
};
 
static cmd_info_t *basic_commands[] = {
    &call0_info,
    &call1_info,
    &call2_info,
    &call3_info,
    &continue_info,
    &cpus_info,
    &desc_info,
    &exit_info,
    &halt_info,
    &help_info,
    &ipc_task_info,
    &set4_info,
    &slabs_info,
    &symaddr_info,
    &sched_info,
    &threads_info,
    &tasks_info,
    &tlb_info,
    &version_info,
    &zones_info,
    &zone_info,
    NULL
};
 
 
/** Initialize command info structure.
 *
 * @param cmd Command info structure.
 *
 */
void cmd_initialize(cmd_info_t *cmd)
{
    spinlock_initialize(&cmd->lock, "cmd");
    link_initialize(&cmd->link);
}
 
/** Initialize and register commands. */
void cmd_init(void)
{
    int i;
 
    for (i=0;basic_commands[i]; i++) {
        cmd_initialize(basic_commands[i]);
        if (!cmd_register(basic_commands[i]))
            panic("could not register command %s\n",
                  basic_commands[i]->name);
    }
}
 
 
/** List supported commands.
 *
 * @param argv Argument vector.
 *
 * @return 0 on failure, 1 on success.
 */
int cmd_help(cmd_arg_t *argv)
{
    link_t *cur;
 
    spinlock_lock(&cmd_lock);
   
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
        cmd_info_t *hlp;
       
        hlp = list_get_instance(cur, cmd_info_t, link);
        spinlock_lock(&hlp->lock);
       
        printf("%s - %s\n", hlp->name, hlp->description);
 
        spinlock_unlock(&hlp->lock);
    }
   
    spinlock_unlock(&cmd_lock);
 
    return 1;
}
 
/** Describe specified command.
 *
 * @param argv Argument vector.
 *
 * @return 0 on failure, 1 on success.
 */
int cmd_desc(cmd_arg_t *argv)
{
    link_t *cur;
 
    spinlock_lock(&cmd_lock);
   
    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
        cmd_info_t *hlp;
       
        hlp = list_get_instance(cur, cmd_info_t, link);
        spinlock_lock(&hlp->lock);
 
        if (strncmp(hlp->name, (const char *) argv->buffer, strlen(hlp->name)) == 0) {
            printf("%s - %s\n", hlp->name, hlp->description);
            if (hlp->help)
                hlp->help();
            spinlock_unlock(&hlp->lock);
            break;
        }
 
        spinlock_unlock(&hlp->lock);
    }
   
    spinlock_unlock(&cmd_lock);
 
    return 1;
}
 
/** Search symbol table */
int cmd_symaddr(cmd_arg_t *argv)
{
    symtab_print_search(argv->buffer);
   
    return 1;
}
 
/** Call function with zero parameters */
int cmd_call0(cmd_arg_t *argv)
{
    __address symaddr;
    char *symbol;
    __native (*f)(void);
 
    symaddr = get_symbol_addr(argv->buffer);
    if (!symaddr)
        printf("Symbol %s not found.\n", argv->buffer);
    else if (symaddr == (__address) -1) {
        symtab_print_search(argv->buffer);
        printf("Duplicate symbol, be more specific.\n");
    } else {
        symbol = get_symtab_entry(symaddr);
        printf("Calling f(): %.*p: %s\n", sizeof(__address) * 2, symaddr, symbol);
        f =  (__native (*)(void)) symaddr;
        printf("Result: %#zx\n", f());
    }
   
    return 1;
}
 
/** Call function with one parameter */
int cmd_call1(cmd_arg_t *argv)
{
    __address symaddr;
    char *symbol;
    __native (*f)(__native,...);
    __native arg1 = argv[1].intval;
 
    symaddr = get_symbol_addr(argv->buffer);
    if (!symaddr)
        printf("Symbol %s not found.\n", argv->buffer);
    else if (symaddr == (__address) -1) {
        symtab_print_search(argv->buffer);
        printf("Duplicate symbol, be more specific.\n");
    } else {
        symbol = get_symtab_entry(symaddr);
        printf("Calling f(0x%zX): %.*p: %s\n", arg1, sizeof(__address) * 2, symaddr, symbol);
        f =  (__native (*)(__native,...)) symaddr;
        printf("Result: %#zx\n", f(arg1));
    }
   
    return 1;
}
 
/** Call function with two parameters */
int cmd_call2(cmd_arg_t *argv)
{
    __address symaddr;
    char *symbol;
    __native (*f)(__native,__native,...);
    __native arg1 = argv[1].intval;
    __native arg2 = argv[2].intval;
 
    symaddr = get_symbol_addr(argv->buffer);
    if (!symaddr)
        printf("Symbol %s not found.\n", argv->buffer);
    else if (symaddr == (__address) -1) {
        symtab_print_search(argv->buffer);
        printf("Duplicate symbol, be more specific.\n");
    } else {
        symbol = get_symtab_entry(symaddr);
        printf("Calling f(0x%zx,0x%zx): %.*p: %s\n",
               arg1, arg2, sizeof(__address) * 2, symaddr, symbol);
        f =  (__native (*)(__native,__native,...)) symaddr;
        printf("Result: %#zx\n", f(arg1, arg2));
    }
   
    return 1;
}
 
/** Call function with three parameters */
int cmd_call3(cmd_arg_t *argv)
{
    __address symaddr;
    char *symbol;
    __native (*f)(__native,__native,__native,...);
    __native arg1 = argv[1].intval;
    __native arg2 = argv[2].intval;
    __native arg3 = argv[3].intval;
 
    symaddr = get_symbol_addr(argv->buffer);
    if (!symaddr)
        printf("Symbol %s not found.\n", argv->buffer);
    else if (symaddr == (__address) -1) {
        symtab_print_search(argv->buffer);
        printf("Duplicate symbol, be more specific.\n");
    } else {
        symbol = get_symtab_entry(symaddr);
        printf("Calling f(0x%zx,0x%zx, 0x%zx): %.*p: %s\n",
               arg1, arg2, arg3, sizeof(__address) * 2, symaddr, symbol);
        f =  (__native (*)(__native,__native,__native,...)) symaddr;
        printf("Result: %#zx\n", f(arg1, arg2, arg3));
    }
   
    return 1;
}
 
 
/** Print detailed description of 'describe' command. */
void desc_help(void)
{
    printf("Syntax: describe command_name\n");
}
 
/** Halt the kernel.
 *
 * @param argv Argument vector (ignored).
 *
 * @return 0 on failure, 1 on success (never returns).
 */
int cmd_halt(cmd_arg_t *argv)
{
    halt();
    return 1;
}
 
/** Command for printing TLB contents.
 *
 * @param argv Not used.
 *
 * @return Always returns 1.
 */
int cmd_tlb(cmd_arg_t *argv)
{
    tlb_print();
    return 1;
}
 
/** Write 4 byte value to address */
int cmd_set4(cmd_arg_t *argv)
{
    __u32 *addr ;
    __u32 arg1 = argv[1].intval;
    bool pointer = false;
 
    if (((char *)argv->buffer)[0] == '*') {
        addr = (__u32 *) get_symbol_addr(argv->buffer+1);
        pointer = true;
    } else if (((char *)argv->buffer)[0] >= '0' &&
           ((char *)argv->buffer)[0] <= '9')
        addr = (__u32 *)atoi((char *)argv->buffer);
    else
        addr = (__u32 *)get_symbol_addr(argv->buffer);
 
    if (!addr)
        printf("Symbol %s not found.\n", argv->buffer);
    else if (addr == (__u32 *) -1) {
        symtab_print_search(argv->buffer);
        printf("Duplicate symbol, be more specific.\n");
    } else {
        if (pointer)
            addr = (__u32 *)(*(__native *)addr);
        printf("Writing 0x%x -> %.*p\n", arg1, sizeof(__address) * 2, addr);
        *addr = arg1;
       
    }
   
    return 1;
}
 
/** Command for listings SLAB caches
 *
 * @param argv Ignores
 *
 * @return Always 1
 */
int cmd_slabs(cmd_arg_t * argv) {
    slab_print_list();
    return 1;
}
 
 
/** Command for listings Thread information
 *
 * @param argv Ignores
 *
 * @return Always 1
 */
int cmd_threads(cmd_arg_t * argv) {
    thread_print_list();
    return 1;
}
 
/** Command for listings Task information
 *
 * @param argv Ignores
 *
 * @return Always 1
 */
int cmd_tasks(cmd_arg_t * argv) {
    task_print_list();
    return 1;
}
 
/** Command for listings Thread information
 *
 * @param argv Ignores
 *
 * @return Always 1
 */
int cmd_sched(cmd_arg_t * argv) {
    sched_print_list();
    return 1;
}
 
/** Command for listing memory zones
 *
 * @param argv Ignored
 *
 * return Always 1
 */
int cmd_zones(cmd_arg_t * argv) {
    zone_print_list();
    return 1;
}
 
/** Command for memory zone details
 *
 * @param argv Integer argument from cmdline expected
 *
 * return Always 1
 */
int cmd_zone(cmd_arg_t * argv) {
    zone_print_one(argv[0].intval);
    return 1;
}
 
/** Command for printing task ipc details
 *
 * @param argv Integer argument from cmdline expected
 *
 * return Always 1
 */
int cmd_ipc_task(cmd_arg_t * argv) {
    ipc_print_task(argv[0].intval);
    return 1;
}
 
 
/** Command for listing processors.
 *
 * @param argv Ignored.
 *
 * return Always 1.
 */
int cmd_cpus(cmd_arg_t *argv)
{
    cpu_list();
    return 1;
}
 
/** Command for printing kernel version.
 *
 * @param argv Ignored.
 *
 * return Always 1.
 */
int cmd_version(cmd_arg_t *argv)
{
    version_print();
    return 1;
}
 
/** Command for returning console back to userspace.
 *
 * @param argv Ignored.
 *
 * return Always 1.
 */
int cmd_continue(cmd_arg_t *argv)
{
    arch_release_console();
    return 1;
}
 

Rev 1474	Rev 1573
1	/*	1	/*
2	* Copyright (C) 2005 Jakub Jermar	2	* Copyright (C) 2005 Jakub Jermar
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	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	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.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	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	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	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	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	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	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.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/**	29	/**
30	* @file cmd.c	30	* @file cmd.c
31	* @brief Kernel console command wrappers.	31	* @brief Kernel console command wrappers.
32	*	32	*
33	* This file is meant to contain all wrapper functions for	33	* This file is meant to contain all wrapper functions for
34	* all kconsole commands. The point is in separating	34	* all kconsole commands. The point is in separating
35	* kconsole specific wrappers from kconsole-unaware functions	35	* kconsole specific wrappers from kconsole-unaware functions
36	* from other subsystems.	36	* from other subsystems.
37	*/	37	*/
38		38
39	#include <console/cmd.h>	39	#include <console/cmd.h>
40	#include <console/console.h>	40	#include <console/console.h>
41	#include <console/kconsole.h>	41	#include <console/kconsole.h>
42	#include <print.h>	42	#include <print.h>
43	#include <panic.h>	43	#include <panic.h>
44	#include <typedefs.h>	44	#include <typedefs.h>
45	#include <arch/types.h>	45	#include <arch/types.h>
46	#include <adt/list.h>	46	#include <adt/list.h>
47	#include <arch.h>	47	#include <arch.h>
48	#include <func.h>	48	#include <func.h>
49	#include <macros.h>	49	#include <macros.h>
50	#include <debug.h>	50	#include <debug.h>
51	#include <symtab.h>	51	#include <symtab.h>
52	#include <cpu.h>	52	#include <cpu.h>
53	#include <mm/tlb.h>	53	#include <mm/tlb.h>
54	#include <arch/mm/tlb.h>	54	#include <arch/mm/tlb.h>
55	#include <mm/frame.h>	55	#include <mm/frame.h>
56	#include <main/version.h>	56	#include <main/version.h>
57	#include <mm/slab.h>	57	#include <mm/slab.h>
58	#include <proc/scheduler.h>	58	#include <proc/scheduler.h>
59	#include <proc/thread.h>	59	#include <proc/thread.h>
60	#include <proc/task.h>	60	#include <proc/task.h>
-		61	#include <ipc/ipc.h>
61		62
62	/** Data and methods for 'help' command. */	63	/** Data and methods for 'help' command. */
63	static int cmd_help(cmd_arg_t *argv);	64	static int cmd_help(cmd_arg_t *argv);
64	static cmd_info_t help_info = {	65	static cmd_info_t help_info = {
65	.name = "help",	66	.name = "help",
66	.description = "List of supported commands.",	67	.description = "List of supported commands.",
67	.func = cmd_help,	68	.func = cmd_help,
68	.argc = 0	69	.argc = 0
69	};	70	};
70		71
71	static cmd_info_t exit_info = {	72	static cmd_info_t exit_info = {
72	.name = "exit",	73	.name = "exit",
73	.description ="Exit kconsole",	74	.description ="Exit kconsole",
74	.argc = 0	75	.argc = 0
75	};	76	};
76		77
77	static int cmd_continue(cmd_arg_t *argv);	78	static int cmd_continue(cmd_arg_t *argv);
78	static cmd_info_t continue_info = {	79	static cmd_info_t continue_info = {
79	.name = "continue",	80	.name = "continue",
80	.description ="Return console back to userspace",	81	.description ="Return console back to userspace",
81	.func = cmd_continue,	82	.func = cmd_continue,
82	.argc = 0	83	.argc = 0
83	};	84	};
84		85
85	/** Data and methods for 'description' command. */	86	/** Data and methods for 'description' command. */
86	static int cmd_desc(cmd_arg_t *argv);	87	static int cmd_desc(cmd_arg_t *argv);
87	static void desc_help(void);	88	static void desc_help(void);
88	static char desc_buf[MAX_CMDLINE+1];	89	static char desc_buf[MAX_CMDLINE+1];
89	static cmd_arg_t desc_argv = {	90	static cmd_arg_t desc_argv = {
90	.type = ARG_TYPE_STRING,	91	.type = ARG_TYPE_STRING,
91	.buffer = desc_buf,	92	.buffer = desc_buf,
92	.len = sizeof(desc_buf)	93	.len = sizeof(desc_buf)
93	};	94	};
94	static cmd_info_t desc_info = {	95	static cmd_info_t desc_info = {
95	.name = "describe",	96	.name = "describe",
96	.description = "Describe specified command.",	97	.description = "Describe specified command.",
97	.help = desc_help,	98	.help = desc_help,
98	.func = cmd_desc,	99	.func = cmd_desc,
99	.argc = 1,	100	.argc = 1,
100	.argv = &desc_argv	101	.argv = &desc_argv
101	};	102	};
102		103
103	/** Data and methods for 'symaddr' command. */	104	/** Data and methods for 'symaddr' command. */
104	static int cmd_symaddr(cmd_arg_t *argv);	105	static int cmd_symaddr(cmd_arg_t *argv);
105	static char symaddr_buf[MAX_CMDLINE+1];	106	static char symaddr_buf[MAX_CMDLINE+1];
106	static cmd_arg_t symaddr_argv = {	107	static cmd_arg_t symaddr_argv = {
107	.type = ARG_TYPE_STRING,	108	.type = ARG_TYPE_STRING,
108	.buffer = symaddr_buf,	109	.buffer = symaddr_buf,
109	.len = sizeof(symaddr_buf)	110	.len = sizeof(symaddr_buf)
110	};	111	};
111	static cmd_info_t symaddr_info = {	112	static cmd_info_t symaddr_info = {
112	.name = "symaddr",	113	.name = "symaddr",
113	.description = "Return symbol address.",	114	.description = "Return symbol address.",
114	.func = cmd_symaddr,	115	.func = cmd_symaddr,
115	.argc = 1,	116	.argc = 1,
116	.argv = &symaddr_argv	117	.argv = &symaddr_argv
117	};	118	};
118		119
119	static char set_buf[MAX_CMDLINE+1];	120	static char set_buf[MAX_CMDLINE+1];
120	static int cmd_set4(cmd_arg_t *argv);	121	static int cmd_set4(cmd_arg_t *argv);
121	static cmd_arg_t set4_argv[] = {	122	static cmd_arg_t set4_argv[] = {
122	{	123	{
123	.type = ARG_TYPE_STRING,	124	.type = ARG_TYPE_STRING,
124	.buffer = set_buf,	125	.buffer = set_buf,
125	.len = sizeof(set_buf)	126	.len = sizeof(set_buf)
126	},	127	},
127	{	128	{
128	.type = ARG_TYPE_INT	129	.type = ARG_TYPE_INT
129	}	130	}
130	};	131	};
131	static cmd_info_t set4_info = {	132	static cmd_info_t set4_info = {
132	.name = "set4",	133	.name = "set4",
133	.description = "set <dest_addr> <value> - 4byte version",	134	.description = "set <dest_addr> <value> - 4byte version",
134	.func = cmd_set4,	135	.func = cmd_set4,
135	.argc = 2,	136	.argc = 2,
136	.argv = set4_argv	137	.argv = set4_argv
137	};	138	};
138		139
139	/** Data and methods for 'call0' command. */	140	/** Data and methods for 'call0' command. */
140	static char call0_buf[MAX_CMDLINE+1];	141	static char call0_buf[MAX_CMDLINE+1];
141	static char carg1_buf[MAX_CMDLINE+1];	142	static char carg1_buf[MAX_CMDLINE+1];
142	static char carg2_buf[MAX_CMDLINE+1];	143	static char carg2_buf[MAX_CMDLINE+1];
143	static char carg3_buf[MAX_CMDLINE+1];	144	static char carg3_buf[MAX_CMDLINE+1];
144		145
145	static int cmd_call0(cmd_arg_t *argv);	146	static int cmd_call0(cmd_arg_t *argv);
146	static cmd_arg_t call0_argv = {	147	static cmd_arg_t call0_argv = {
147	.type = ARG_TYPE_STRING,	148	.type = ARG_TYPE_STRING,
148	.buffer = call0_buf,	149	.buffer = call0_buf,
149	.len = sizeof(call0_buf)	150	.len = sizeof(call0_buf)
150	};	151	};
151	static cmd_info_t call0_info = {	152	static cmd_info_t call0_info = {
152	.name = "call0",	153	.name = "call0",
153	.description = "call0 <function> -> call function().",	154	.description = "call0 <function> -> call function().",
154	.func = cmd_call0,	155	.func = cmd_call0,
155	.argc = 1,	156	.argc = 1,
156	.argv = &call0_argv	157	.argv = &call0_argv
157	};	158	};
158		159
159	/** Data and methods for 'call1' command. */	160	/** Data and methods for 'call1' command. */
160	static int cmd_call1(cmd_arg_t *argv);	161	static int cmd_call1(cmd_arg_t *argv);
161	static cmd_arg_t call1_argv[] = {	162	static cmd_arg_t call1_argv[] = {
162	{	163	{
163	.type = ARG_TYPE_STRING,	164	.type = ARG_TYPE_STRING,
164	.buffer = call0_buf,	165	.buffer = call0_buf,
165	.len = sizeof(call0_buf)	166	.len = sizeof(call0_buf)
166	},	167	},
167	{	168	{
168	.type = ARG_TYPE_VAR,	169	.type = ARG_TYPE_VAR,
169	.buffer = carg1_buf,	170	.buffer = carg1_buf,
170	.len = sizeof(carg1_buf)	171	.len = sizeof(carg1_buf)
171	}	172	}
172	};	173	};
173	static cmd_info_t call1_info = {	174	static cmd_info_t call1_info = {
174	.name = "call1",	175	.name = "call1",
175	.description = "call1 <function> <arg1> -> call function(arg1).",	176	.description = "call1 <function> <arg1> -> call function(arg1).",
176	.func = cmd_call1,	177	.func = cmd_call1,
177	.argc = 2,	178	.argc = 2,
178	.argv = call1_argv	179	.argv = call1_argv
179	};	180	};
180		181
181	/** Data and methods for 'call2' command. */	182	/** Data and methods for 'call2' command. */
182	static int cmd_call2(cmd_arg_t *argv);	183	static int cmd_call2(cmd_arg_t *argv);
183	static cmd_arg_t call2_argv[] = {	184	static cmd_arg_t call2_argv[] = {
184	{	185	{
185	.type = ARG_TYPE_STRING,	186	.type = ARG_TYPE_STRING,
186	.buffer = call0_buf,	187	.buffer = call0_buf,
187	.len = sizeof(call0_buf)	188	.len = sizeof(call0_buf)
188	},	189	},
189	{	190	{
190	.type = ARG_TYPE_VAR,	191	.type = ARG_TYPE_VAR,
191	.buffer = carg1_buf,	192	.buffer = carg1_buf,
192	.len = sizeof(carg1_buf)	193	.len = sizeof(carg1_buf)
193	},	194	},
194	{	195	{
195	.type = ARG_TYPE_VAR,	196	.type = ARG_TYPE_VAR,
196	.buffer = carg2_buf,	197	.buffer = carg2_buf,
197	.len = sizeof(carg2_buf)	198	.len = sizeof(carg2_buf)
198	}	199	}
199	};	200	};
200	static cmd_info_t call2_info = {	201	static cmd_info_t call2_info = {
201	.name = "call2",	202	.name = "call2",
202	.description = "call2 <function> <arg1> <arg2> -> call function(arg1,arg2).",	203	.description = "call2 <function> <arg1> <arg2> -> call function(arg1,arg2).",
203	.func = cmd_call2,	204	.func = cmd_call2,
204	.argc = 3,	205	.argc = 3,
205	.argv = call2_argv	206	.argv = call2_argv
206	};	207	};
207		208
208	/** Data and methods for 'call3' command. */	209	/** Data and methods for 'call3' command. */
209	static int cmd_call3(cmd_arg_t *argv);	210	static int cmd_call3(cmd_arg_t *argv);
210	static cmd_arg_t call3_argv[] = {	211	static cmd_arg_t call3_argv[] = {
211	{	212	{
212	.type = ARG_TYPE_STRING,	213	.type = ARG_TYPE_STRING,
213	.buffer = call0_buf,	214	.buffer = call0_buf,
214	.len = sizeof(call0_buf)	215	.len = sizeof(call0_buf)
215	},	216	},
216	{	217	{
217	.type = ARG_TYPE_VAR,	218	.type = ARG_TYPE_VAR,
218	.buffer = carg1_buf,	219	.buffer = carg1_buf,
219	.len = sizeof(carg1_buf)	220	.len = sizeof(carg1_buf)
220	},	221	},
221	{	222	{
222	.type = ARG_TYPE_VAR,	223	.type = ARG_TYPE_VAR,
223	.buffer = carg2_buf,	224	.buffer = carg2_buf,
224	.len = sizeof(carg2_buf)	225	.len = sizeof(carg2_buf)
225	},	226	},
226	{	227	{
227	.type = ARG_TYPE_VAR,	228	.type = ARG_TYPE_VAR,
228	.buffer = carg3_buf,	229	.buffer = carg3_buf,
229	.len = sizeof(carg3_buf)	230	.len = sizeof(carg3_buf)
230	}	231	}
231		232
232	};	233	};
233	static cmd_info_t call3_info = {	234	static cmd_info_t call3_info = {
234	.name = "call3",	235	.name = "call3",
235	.description = "call3 <function> <arg1> <arg2> <arg3> -> call function(arg1,arg2,arg3).",	236	.description = "call3 <function> <arg1> <arg2> <arg3> -> call function(arg1,arg2,arg3).",
236	.func = cmd_call3,	237	.func = cmd_call3,
237	.argc = 4,	238	.argc = 4,
238	.argv = call3_argv	239	.argv = call3_argv
239	};	240	};
240		241
241	/** Data and methods for 'halt' command. */	242	/** Data and methods for 'halt' command. */
242	static int cmd_halt(cmd_arg_t *argv);	243	static int cmd_halt(cmd_arg_t *argv);
243	static cmd_info_t halt_info = {	244	static cmd_info_t halt_info = {
244	.name = "halt",	245	.name = "halt",
245	.description = "Halt the kernel.",	246	.description = "Halt the kernel.",
246	.func = cmd_halt,	247	.func = cmd_halt,
247	.argc = 0	248	.argc = 0
248	};	249	};
249		250
250	/** Data and methods for 'tlb' command. */	251	/** Data and methods for 'tlb' command. */
251	static int cmd_tlb(cmd_arg_t *argv);	252	static int cmd_tlb(cmd_arg_t *argv);
252	cmd_info_t tlb_info = {	253	cmd_info_t tlb_info = {
253	.name = "tlb",	254	.name = "tlb",
254	.description = "Print TLB of current processor.",	255	.description = "Print TLB of current processor.",
255	.help = NULL,	256	.help = NULL,
256	.func = cmd_tlb,	257	.func = cmd_tlb,
257	.argc = 0,	258	.argc = 0,
258	.argv = NULL	259	.argv = NULL
259	};	260	};
260		261
261	static int cmd_threads(cmd_arg_t *argv);	262	static int cmd_threads(cmd_arg_t *argv);
262	static cmd_info_t threads_info = {	263	static cmd_info_t threads_info = {
263	.name = "threads",	264	.name = "threads",
264	.description = "List all threads",	265	.description = "List all threads",
265	.func = cmd_threads,	266	.func = cmd_threads,
266	.argc = 0	267	.argc = 0
267	};	268	};
268		269
269	static int cmd_tasks(cmd_arg_t *argv);	270	static int cmd_tasks(cmd_arg_t *argv);
270	static cmd_info_t tasks_info = {	271	static cmd_info_t tasks_info = {
271	.name = "tasks",	272	.name = "tasks",
272	.description = "List all tasks",	273	.description = "List all tasks",
273	.func = cmd_tasks,	274	.func = cmd_tasks,
274	.argc = 0	275	.argc = 0
275	};	276	};
276		277
277		278
278	static int cmd_sched(cmd_arg_t *argv);	279	static int cmd_sched(cmd_arg_t *argv);
279	static cmd_info_t sched_info = {	280	static cmd_info_t sched_info = {
280	.name = "scheduler",	281	.name = "scheduler",
281	.description = "List all scheduler information",	282	.description = "List all scheduler information",
282	.func = cmd_sched,	283	.func = cmd_sched,
283	.argc = 0	284	.argc = 0
284	};	285	};
285		286
286	static int cmd_slabs(cmd_arg_t *argv);	287	static int cmd_slabs(cmd_arg_t *argv);
287	static cmd_info_t slabs_info = {	288	static cmd_info_t slabs_info = {
288	.name = "slabs",	289	.name = "slabs",
289	.description = "List SLAB caches.",	290	.description = "List SLAB caches.",
290	.func = cmd_slabs,	291	.func = cmd_slabs,
291	.argc = 0	292	.argc = 0
292	};	293	};
293		294
294	/** Data and methods for 'zones' command */	295	/** Data and methods for 'zones' command */
295	static int cmd_zones(cmd_arg_t *argv);	296	static int cmd_zones(cmd_arg_t *argv);
296	static cmd_info_t zones_info = {	297	static cmd_info_t zones_info = {
297	.name = "zones",	298	.name = "zones",
298	.description = "List of memory zones.",	299	.description = "List of memory zones.",
299	.func = cmd_zones,	300	.func = cmd_zones,
300	.argc = 0	301	.argc = 0
301	};	302	};
302		303
-		304	/** Data and methods for 'ipc_task' command */
-		305	static int cmd_ipc_task(cmd_arg_t *argv);
-		306	static cmd_arg_t ipc_task_argv = {
-		307	.type = ARG_TYPE_INT,
-		308	};
-		309	static cmd_info_t ipc_task_info = {
-		310	.name = "ipc_task",
-		311	.description = "Show memory zone structure.",
-		312	.func = cmd_ipc_task,
-		313	.argc = 1,
-		314	.argv = &ipc_task_argv
-		315	};
-		316
303	/** Data and methods for 'zone' command */	317	/** Data and methods for 'zone' command */
304	static int cmd_zone(cmd_arg_t *argv);	318	static int cmd_zone(cmd_arg_t *argv);
305	static cmd_arg_t zone_argv = {	319	static cmd_arg_t zone_argv = {
306	.type = ARG_TYPE_INT,	320	.type = ARG_TYPE_INT,
307	};	321	};
308		322
309	static cmd_info_t zone_info = {	323	static cmd_info_t zone_info = {
310	.name = "zone",	324	.name = "zone",
311	.description = "Show memory zone structure.",	325	.description = "Show memory zone structure.",
312	.func = cmd_zone,	326	.func = cmd_zone,
313	.argc = 1,	327	.argc = 1,
314	.argv = &zone_argv	328	.argv = &zone_argv
315	};	329	};
316		330
317	/** Data and methods for 'cpus' command. */	331	/** Data and methods for 'cpus' command. */
318	static int cmd_cpus(cmd_arg_t *argv);	332	static int cmd_cpus(cmd_arg_t *argv);
319	cmd_info_t cpus_info = {	333	cmd_info_t cpus_info = {
320	.name = "cpus",	334	.name = "cpus",
321	.description = "List all processors.",	335	.description = "List all processors.",
322	.help = NULL,	336	.help = NULL,
323	.func = cmd_cpus,	337	.func = cmd_cpus,
324	.argc = 0,	338	.argc = 0,
325	.argv = NULL	339	.argv = NULL
326	};	340	};
327		341
328	/** Data and methods for 'version' command. */	342	/** Data and methods for 'version' command. */
329	static int cmd_version(cmd_arg_t *argv);	343	static int cmd_version(cmd_arg_t *argv);
330	cmd_info_t version_info = {	344	cmd_info_t version_info = {
331	.name = "version",	345	.name = "version",
332	.description = "Print version information.",	346	.description = "Print version information.",
333	.help = NULL,	347	.help = NULL,
334	.func = cmd_version,	348	.func = cmd_version,
335	.argc = 0,	349	.argc = 0,
336	.argv = NULL	350	.argv = NULL
337	};	351	};
338		352
339	static cmd_info_t *basic_commands[] = {	353	static cmd_info_t *basic_commands[] = {
340	&call0_info,	354	&call0_info,
341	&call1_info,	355	&call1_info,
342	&call2_info,	356	&call2_info,
343	&call3_info,	357	&call3_info,
344	&continue_info,	358	&continue_info,
345	&cpus_info,	359	&cpus_info,
346	&desc_info,	360	&desc_info,
347	&exit_info,	361	&exit_info,
348	&halt_info,	362	&halt_info,
349	&help_info,	363	&help_info,
-		364	&ipc_task_info,
350	&set4_info,	365	&set4_info,
351	&slabs_info,	366	&slabs_info,
352	&symaddr_info,	367	&symaddr_info,
353	&sched_info,	368	&sched_info,
354	&threads_info,	369	&threads_info,
355	&tasks_info,	370	&tasks_info,
356	&tlb_info,	371	&tlb_info,
357	&version_info,	372	&version_info,
358	&zones_info,	373	&zones_info,
359	&zone_info,	374	&zone_info,
360	NULL	375	NULL
361	};	376	};
362		377
363		378
364	/** Initialize command info structure.	379	/** Initialize command info structure.
365	*	380	*
366	* @param cmd Command info structure.	381	* @param cmd Command info structure.
367	*	382	*
368	*/	383	*/
369	void cmd_initialize(cmd_info_t *cmd)	384	void cmd_initialize(cmd_info_t *cmd)
370	{	385	{
371	spinlock_initialize(&cmd->lock, "cmd");	386	spinlock_initialize(&cmd->lock, "cmd");
372	link_initialize(&cmd->link);	387	link_initialize(&cmd->link);
373	}	388	}
374		389
375	/** Initialize and register commands. */	390	/** Initialize and register commands. */
376	void cmd_init(void)	391	void cmd_init(void)
377	{	392	{
378	int i;	393	int i;
379		394
380	for (i=0;basic_commands[i]; i++) {	395	for (i=0;basic_commands[i]; i++) {
381	cmd_initialize(basic_commands[i]);	396	cmd_initialize(basic_commands[i]);
382	if (!cmd_register(basic_commands[i]))	397	if (!cmd_register(basic_commands[i]))
383	panic("could not register command %s\n",	398	panic("could not register command %s\n",
384	basic_commands[i]->name);	399	basic_commands[i]->name);
385	}	400	}
386	}	401	}
387		402
388		403
389	/** List supported commands.	404	/** List supported commands.
390	*	405	*
391	* @param argv Argument vector.	406	* @param argv Argument vector.
392	*	407	*
393	* @return 0 on failure, 1 on success.	408	* @return 0 on failure, 1 on success.
394	*/	409	*/
395	int cmd_help(cmd_arg_t *argv)	410	int cmd_help(cmd_arg_t *argv)
396	{	411	{
397	link_t *cur;	412	link_t *cur;
398		413
399	spinlock_lock(&cmd_lock);	414	spinlock_lock(&cmd_lock);
400		415
401	for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {	416	for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
402	cmd_info_t *hlp;	417	cmd_info_t *hlp;
403		418
404	hlp = list_get_instance(cur, cmd_info_t, link);	419	hlp = list_get_instance(cur, cmd_info_t, link);
405	spinlock_lock(&hlp->lock);	420	spinlock_lock(&hlp->lock);
406		421
407	printf("%s - %s\n", hlp->name, hlp->description);	422	printf("%s - %s\n", hlp->name, hlp->description);
408		423
409	spinlock_unlock(&hlp->lock);	424	spinlock_unlock(&hlp->lock);
410	}	425	}
411		426
412	spinlock_unlock(&cmd_lock);	427	spinlock_unlock(&cmd_lock);
413		428
414	return 1;	429	return 1;
415	}	430	}
416		431
417	/** Describe specified command.	432	/** Describe specified command.
418	*	433	*
419	* @param argv Argument vector.	434	* @param argv Argument vector.
420	*	435	*
421	* @return 0 on failure, 1 on success.	436	* @return 0 on failure, 1 on success.
422	*/	437	*/
423	int cmd_desc(cmd_arg_t *argv)	438	int cmd_desc(cmd_arg_t *argv)
424	{	439	{
425	link_t *cur;	440	link_t *cur;
426		441
427	spinlock_lock(&cmd_lock);	442	spinlock_lock(&cmd_lock);
428		443
429	for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {	444	for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
430	cmd_info_t *hlp;	445	cmd_info_t *hlp;
431		446
432	hlp = list_get_instance(cur, cmd_info_t, link);	447	hlp = list_get_instance(cur, cmd_info_t, link);
433	spinlock_lock(&hlp->lock);	448	spinlock_lock(&hlp->lock);
434		449
435	if (strncmp(hlp->name, (const char *) argv->buffer, strlen(hlp->name)) == 0) {	450	if (strncmp(hlp->name, (const char *) argv->buffer, strlen(hlp->name)) == 0) {
436	printf("%s - %s\n", hlp->name, hlp->description);	451	printf("%s - %s\n", hlp->name, hlp->description);
437	if (hlp->help)	452	if (hlp->help)
438	hlp->help();	453	hlp->help();
439	spinlock_unlock(&hlp->lock);	454	spinlock_unlock(&hlp->lock);
440	break;	455	break;
441	}	456	}
442		457
443	spinlock_unlock(&hlp->lock);	458	spinlock_unlock(&hlp->lock);
444	}	459	}
445		460
446	spinlock_unlock(&cmd_lock);	461	spinlock_unlock(&cmd_lock);
447		462
448	return 1;	463	return 1;
449	}	464	}
450		465
451	/** Search symbol table */	466	/** Search symbol table */
452	int cmd_symaddr(cmd_arg_t *argv)	467	int cmd_symaddr(cmd_arg_t *argv)
453	{	468	{
454	symtab_print_search(argv->buffer);	469	symtab_print_search(argv->buffer);
455		470
456	return 1;	471	return 1;
457	}	472	}
458		473
459	/** Call function with zero parameters */	474	/** Call function with zero parameters */
460	int cmd_call0(cmd_arg_t *argv)	475	int cmd_call0(cmd_arg_t *argv)
461	{	476	{
462	__address symaddr;	477	__address symaddr;
463	char *symbol;	478	char *symbol;
464	__native (*f)(void);	479	__native (*f)(void);
465		480
466	symaddr = get_symbol_addr(argv->buffer);	481	symaddr = get_symbol_addr(argv->buffer);
467	if (!symaddr)	482	if (!symaddr)
468	printf("Symbol %s not found.\n", argv->buffer);	483	printf("Symbol %s not found.\n", argv->buffer);
469	else if (symaddr == (__address) -1) {	484	else if (symaddr == (__address) -1) {
470	symtab_print_search(argv->buffer);	485	symtab_print_search(argv->buffer);
471	printf("Duplicate symbol, be more specific.\n");	486	printf("Duplicate symbol, be more specific.\n");
472	} else {	487	} else {
473	symbol = get_symtab_entry(symaddr);	488	symbol = get_symtab_entry(symaddr);
474	printf("Calling f(): %.p: %s\n", sizeof(__address) 2, symaddr, symbol);	489	printf("Calling f(): %.p: %s\n", sizeof(__address) 2, symaddr, symbol);
475	f = (__native (*)(void)) symaddr;	490	f = (__native (*)(void)) symaddr;
476	printf("Result: %#zx\n", f());	491	printf("Result: %#zx\n", f());
477	}	492	}
478		493
479	return 1;	494	return 1;
480	}	495	}
481		496
482	/** Call function with one parameter */	497	/** Call function with one parameter */
483	int cmd_call1(cmd_arg_t *argv)	498	int cmd_call1(cmd_arg_t *argv)
484	{	499	{
485	__address symaddr;	500	__address symaddr;

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/generic/src/console/cmd.c – Rev 1474 → 1573