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

Subversion Repositories HelenOS-historic

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