WebSVN – HelenOS – Diff – /trunk/kernel/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 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
};
 
 
 
 
/** 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;
}
 
/** 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;
}
 

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

Subversion Repositories HelenOS

(root)/trunk/kernel/generic/src/console/cmd.c @ 2114 – Rev 676 → 677