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.
 */
 
 /** @addtogroup genericconsole
 * @{
 */
 
/**
 * @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 = "ipc_task <taskid> Show IPC information of given task.",
    .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);
#ifdef ia64
    struct {
        __native f;
        __native gp;
    }fptr;
#endif
 
    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);
#ifdef ia64
        fptr.f = symaddr;
        fptr.gp = ((__native *)cmd_call2)[1];
        f =  (__native (*)(void)) &fptr;
#else
        f =  (__native (*)(void)) symaddr;
#endif
        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;
#ifdef ia64
    struct {
        __native f;
        __native gp;
    }fptr;
#endif
 
    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);
#ifdef ia64
        fptr.f = symaddr;
        fptr.gp = ((__native *)cmd_call2)[1];
        f =  (__native (*)(__native,...)) &fptr;
#else
        f =  (__native (*)(__native,...)) symaddr;
#endif
        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;
#ifdef ia64
    struct {
        __native f;
        __native gp;
    }fptr;
#endif
 
    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);
#ifdef ia64
        fptr.f = symaddr;
        fptr.gp = ((__native *)cmd_call2)[1];
        f =  (__native (*)(__native,__native,...)) &fptr;
#else
        f =  (__native (*)(__native,__native,...)) symaddr;
#endif
        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;
#ifdef ia64
    struct {
        __native f;
        __native gp;
    }fptr;
#endif
 
    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);
#ifdef ia64
        fptr.f = symaddr;
        fptr.gp = ((__native *)cmd_call2)[1];
        f =  (__native (*)(__native,__native,__native,...)) &fptr;
#else
        f =  (__native (*)(__native,__native,__native,...)) symaddr;
#endif
        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)
{
    printf("The kernel will now relinquish the console.\n");
    printf("Use userspace controls to redraw the screen.\n");
    arch_release_console();
    return 1;
}
 
 /** @}
 */
 
 

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

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/generic/src/console/cmd.c – Rev 1695 → 1702