WebSVN – HelenOS-historic – Diff – /kernel/trunk/generic/src/console/cmd.c


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

Subversion Repositories HelenOS-historic

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