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>
#include <ipc/irq.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)
{
    uintptr_t symaddr;
    char *symbol;
    unative_t (*f)(void);
#ifdef ia64
    struct {
        unative_t f;
        unative_t gp;
    }fptr;
#endif
 
    symaddr = get_symbol_addr(argv->buffer);
    if (!symaddr)
        printf("Symbol %s not found.\n", argv->buffer);
    else if (symaddr == (uintptr_t) -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(uintptr_t) * 2, symaddr, symbol);
#ifdef ia64
        fptr.f = symaddr;
        fptr.gp = ((unative_t *)cmd_call2)[1];
        f =  (unative_t (*)(void)) &fptr;
#else
        f =  (unative_t (*)(void)) symaddr;
#endif
        printf("Result: %#zx\n", f());
    }
   
    return 1;
}
 
/** Call function with one parameter */
int cmd_call1(cmd_arg_t *argv)
{
    uintptr_t symaddr;
    char *symbol;
    unative_t (*f)(unative_t,...);
    unative_t arg1 = argv[1].intval;
#ifdef ia64
    struct {
        unative_t f;
        unative_t gp;
    }fptr;
#endif
 
    symaddr = get_symbol_addr(argv->buffer);
    if (!symaddr)
        printf("Symbol %s not found.\n", argv->buffer);
    else if (symaddr == (uintptr_t) -1) {
        symtab_print_search(argv->buffer);
        printf("Duplicate symbol, be more specific.\n");
    } else {
        symbol = get_symtab_entry(symaddr);
 
        printf("Calling f(%#zx): %.*p: %s\n", arg1, sizeof(uintptr_t) * 2, symaddr, symbol);
#ifdef ia64
        fptr.f = symaddr;
        fptr.gp = ((unative_t *)cmd_call2)[1];
        f =  (unative_t (*)(unative_t,...)) &fptr;
#else
        f =  (unative_t (*)(unative_t,...)) symaddr;
#endif
        printf("Result: %#zx\n", f(arg1));
    }
   
    return 1;
}
 
/** Call function with two parameters */
int cmd_call2(cmd_arg_t *argv)
{
    uintptr_t symaddr;
    char *symbol;
    unative_t (*f)(unative_t,unative_t,...);
    unative_t arg1 = argv[1].intval;
    unative_t arg2 = argv[2].intval;
#ifdef ia64
    struct {
        unative_t f;
        unative_t gp;
    }fptr;
#endif
 
    symaddr = get_symbol_addr(argv->buffer);
    if (!symaddr)
        printf("Symbol %s not found.\n", argv->buffer);
    else if (symaddr == (uintptr_t) -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(uintptr_t) * 2, symaddr, symbol);
#ifdef ia64
        fptr.f = symaddr;
        fptr.gp = ((unative_t *)cmd_call2)[1];
        f =  (unative_t (*)(unative_t,unative_t,...)) &fptr;
#else
        f =  (unative_t (*)(unative_t,unative_t,...)) symaddr;
#endif
        printf("Result: %#zx\n", f(arg1, arg2));
    }
   
    return 1;
}
 
/** Call function with three parameters */
int cmd_call3(cmd_arg_t *argv)
{
    uintptr_t symaddr;
    char *symbol;
    unative_t (*f)(unative_t,unative_t,unative_t,...);
    unative_t arg1 = argv[1].intval;
    unative_t arg2 = argv[2].intval;
    unative_t arg3 = argv[3].intval;
#ifdef ia64
    struct {
        unative_t f;
        unative_t gp;
    }fptr;
#endif
 
    symaddr = get_symbol_addr(argv->buffer);
    if (!symaddr)
        printf("Symbol %s not found.\n", argv->buffer);
    else if (symaddr == (uintptr_t) -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(uintptr_t) * 2, symaddr, symbol);
#ifdef ia64
        fptr.f = symaddr;
        fptr.gp = ((unative_t *)cmd_call2)[1];
        f =  (unative_t (*)(unative_t,unative_t,unative_t,...)) &fptr;
#else
        f =  (unative_t (*)(unative_t,unative_t,unative_t,...)) 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)
{
    uint32_t *addr ;
    uint32_t arg1 = argv[1].intval;
    bool pointer = false;
 
    if (((char *)argv->buffer)[0] == '*') {
        addr = (uint32_t *) get_symbol_addr(argv->buffer+1);
        pointer = true;
    } else if (((char *)argv->buffer)[0] >= '0' &&
           ((char *)argv->buffer)[0] <= '9')
        addr = (uint32_t *)atoi((char *)argv->buffer);
    else
        addr = (uint32_t *)get_symbol_addr(argv->buffer);
 
    if (!addr)
        printf("Symbol %s not found.\n", argv->buffer);
    else if (addr == (uint32_t *) -1) {
        symtab_print_search(argv->buffer);
        printf("Duplicate symbol, be more specific.\n");
    } else {
        if (pointer)
            addr = (uint32_t *)(*(unative_t *)addr);
        printf("Writing 0x%x -> %.*p\n", arg1, sizeof(uintptr_t) * 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();
    ipc_irq_send_msg(IPC_IRQ_KBDRESTART, 0, 0, 0);
    return 1;
}
 
 /** @}
 */
 
 

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

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/generic/src/console/cmd.c – Rev 1735 → 1780