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.
 */
 
/**
 * 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/kconsole.h>
#include <print.h>
#include <panic.h>
#include <typedefs.h>
#include <arch/types.h>
#include <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>
 
/** 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
};
 
/** 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
};
 
 
/** 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 char zone_buf[MAX_CMDLINE+1];
static cmd_arg_t zone_argv = {
    .type = ARG_TYPE_INT,
    .buffer = zone_buf,
    .len = sizeof(zone_buf)
};
 
 
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
};
 
 
 
 
/** 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)
{
    cmd_initialize(&help_info);
    if (!cmd_register(&help_info))
        panic("could not register command %s\n", help_info.name);
 
    cmd_initialize(&desc_info);
    if (!cmd_register(&desc_info))
        panic("could not register command %s\n", desc_info.name);
 
    cmd_initialize(&exit_info);
    if (!cmd_register(&exit_info))
        panic("could not register command %s\n", exit_info.name);
   
    cmd_initialize(&symaddr_info);
    if (!cmd_register(&symaddr_info))
        panic("could not register command %s\n", symaddr_info.name);
 
    cmd_initialize(&call0_info);
    if (!cmd_register(&call0_info))
        panic("could not register command %s\n", call0_info.name);
 
    cmd_initialize(&call1_info);
    if (!cmd_register(&call1_info))
        panic("could not register command %s\n", call1_info.name);
 
    cmd_initialize(&call2_info);
    if (!cmd_register(&call2_info))
        panic("could not register command %s\n", call2_info.name);
 
    cmd_initialize(&call3_info);
    if (!cmd_register(&call3_info))
        panic("could not register command %s\n", call3_info.name);
 
    cmd_initialize(&set4_info);
    if (!cmd_register(&set4_info))
        panic("could not register command %s\n", set4_info.name);
   
    cmd_initialize(&halt_info);
    if (!cmd_register(&halt_info))
        panic("could not register command %s\n", halt_info.name);
 
    cmd_initialize(&tlb_info);
    if (!cmd_register(&tlb_info))
        panic("could not register command %s\n", tlb_info.name);
 
    cmd_initialize(&zones_info);
    if (!cmd_register(&zones_info))
        panic("could not register command %s\n", zones_info.name);
 
    cmd_initialize(&zone_info);
    if (!cmd_register(&zone_info))
        panic("could not register command %s\n", zone_info.name);
 
    cmd_initialize(&cpus_info);
    if (!cmd_register(&cpus_info))
        panic("could not register command %s\n", cpus_info.name);
       
    cmd_initialize(&version_info);
    if (!cmd_register(&version_info))
        panic("could not register command %s\n", version_info.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(): 0x%p: %s\n", symaddr, symbol);
        f =  (__native (*)(void)) symaddr;
        printf("Result: 0x%p\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%x): 0x%p: %s\n", arg1, symaddr, symbol);
        f =  (__native (*)(__native)) symaddr;
        printf("Result: 0x%p\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%x,0x%x): 0x%p: %s\n",
               arg1, arg2, symaddr, symbol);
        f =  (__native (*)(__native,__native)) symaddr;
        printf("Result: 0x%p\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%x,0x%x, 0x%x): 0x%p: %s\n",
               arg1, arg2, arg3, symaddr, symbol);
        f =  (__native (*)(__native,__native,__native)) symaddr;
        printf("Result: 0x%p\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 -> 0x%p\n", arg1, addr);
        *addr = arg1;
       
    }
   
    return 1;
}
 
 
int cmd_zones(cmd_arg_t * argv) {
    printf("Zones listing not implemented\n");
    return 1;
}
 
int cmd_zone(cmd_arg_t * argv) {
    printf("Zone details not implemented\n");
    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;
}
 

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

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/generic/src/console/cmd.c – Rev 668 → 673