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/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
};
 
/** 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,
    &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;
}
 

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

Subversion Repositories HelenOS-historic

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