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 <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
};
 
static int cmd_hello(cmd_arg_t *argv);
static cmd_info_t hello_info = {
    .name = "hello",
    .description = "Hello Message",
    .func = cmd_hello,
    .argc = 0
};
 
/** 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,
    &hello_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(): 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 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;
}
 
 
int cmd_hello(cmd_arg_t *argv)
{
    printf("\nHello, World !!!\n");
    return 1;
}
 

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

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/generic/src/console/cmd.c @ 1072 – Rev 1053 → 1060