WebSVN – HelenOS – Blame – /trunk/kernel/generic/src/console/cmd.c

Rev	Author	Line No.	Line
596	jermar	1	/*
2071	jermar	2	* Copyright (c) 2005 Jakub Jermar
596	jermar	3	* All rights reserved.
		4	*
		5	* Redistribution and use in source and binary forms, with or without
		6	* modification, are permitted provided that the following conditions
		7	* are met:
		8	*
		9	* - Redistributions of source code must retain the above copyright
		10	* notice, this list of conditions and the following disclaimer.
		11	* - Redistributions in binary form must reproduce the above copyright
		12	* notice, this list of conditions and the following disclaimer in the
		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
		15	* derived from this software without specific prior written permission.
		16	*
		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
		19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
		20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
		21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
		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
		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
		26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		27	*/
		28
1888	jermar	29	/** @addtogroup genericconsole
1702	cejka	30	* @{
		31	*/
		32
596	jermar	33	/**
1264	jermar	34	* @file cmd.c
		35	* @brief Kernel console command wrappers.
		36	*
596	jermar	37	* This file is meant to contain all wrapper functions for
		38	* all kconsole commands. The point is in separating
		39	* kconsole specific wrappers from kconsole-unaware functions
		40	* from other subsystems.
		41	*/
		42
		43	#include <console/cmd.h>
1474	palkovsky	44	#include <console/console.h>
596	jermar	45	#include <console/kconsole.h>
		46	#include <print.h>
		47	#include <panic.h>
		48	#include <arch/types.h>
788	jermar	49	#include <adt/list.h>
596	jermar	50	#include <arch.h>
		51	#include <func.h>
		52	#include <macros.h>
		53	#include <debug.h>
		54	#include <symtab.h>
673	jermar	55	#include <cpu.h>
596	jermar	56	#include <mm/tlb.h>
		57	#include <arch/mm/tlb.h>
668	bondari	58	#include <mm/frame.h>
673	jermar	59	#include <main/version.h>
759	palkovsky	60	#include <mm/slab.h>
775	palkovsky	61	#include <proc/scheduler.h>
777	palkovsky	62	#include <proc/thread.h>
1060	palkovsky	63	#include <proc/task.h>
1573	palkovsky	64	#include <ipc/ipc.h>
1712	palkovsky	65	#include <ipc/irq.h>
596	jermar	66
2019	decky	67	#ifdef CONFIG_TEST
		68	#include <test.h>
		69	#endif
		70
1702	cejka	71	/* Data and methods for 'help' command. */
596	jermar	72	static int cmd_help(cmd_arg_t *argv);
		73	static cmd_info_t help_info = {
		74	.name = "help",
		75	.description = "List of supported commands.",
		76	.func = cmd_help,
		77	.argc = 0
		78	};
		79
609	palkovsky	80	static cmd_info_t exit_info = {
		81	.name = "exit",
2019	decky	82	.description = "Exit kconsole",
609	palkovsky	83	.argc = 0
		84	};
		85
1474	palkovsky	86	static int cmd_continue(cmd_arg_t *argv);
		87	static cmd_info_t continue_info = {
		88	.name = "continue",
2019	decky	89	.description = "Return console back to userspace.",
1474	palkovsky	90	.func = cmd_continue,
		91	.argc = 0
		92	};
		93
2019	decky	94	#ifdef CONFIG_TEST
		95	static int cmd_tests(cmd_arg_t *argv);
		96	static cmd_info_t tests_info = {
		97	.name = "tests",
		98	.description = "Print available kernel tests.",
		99	.func = cmd_tests,
		100	.argc = 0
		101	};
		102
		103	static char test_buf[MAX_CMDLINE + 1];
		104	static int cmd_test(cmd_arg_t *argv);
		105	static cmd_arg_t test_argv[] = {
		106	{
		107	.type = ARG_TYPE_STRING,
		108	.buffer = test_buf,
		109	.len = sizeof(test_buf)
		110	}
		111	};
		112	static cmd_info_t test_info = {
		113	.name = "test",
		114	.description = "Run kernel test.",
		115	.func = cmd_test,
		116	.argc = 1,
		117	.argv = test_argv
		118	};
2050	decky	119
		120	static int cmd_bench(cmd_arg_t *argv);
		121	static cmd_arg_t bench_argv[] = {
		122	{
		123	.type = ARG_TYPE_STRING,
		124	.buffer = test_buf,
		125	.len = sizeof(test_buf)
		126	},
		127	{
		128	.type = ARG_TYPE_INT,
		129	}
		130	};
		131	static cmd_info_t bench_info = {
		132	.name = "bench",
		133	.description = "Run kernel test as benchmark.",
		134	.func = cmd_bench,
		135	.argc = 2,
		136	.argv = bench_argv
		137	};
2019	decky	138	#endif
		139
1702	cejka	140	/* Data and methods for 'description' command. */
596	jermar	141	static int cmd_desc(cmd_arg_t *argv);
		142	static void desc_help(void);
		143	static char desc_buf[MAX_CMDLINE+1];
		144	static cmd_arg_t desc_argv = {
		145	.type = ARG_TYPE_STRING,
		146	.buffer = desc_buf,
		147	.len = sizeof(desc_buf)
		148	};
		149	static cmd_info_t desc_info = {
		150	.name = "describe",
		151	.description = "Describe specified command.",
		152	.help = desc_help,
		153	.func = cmd_desc,
		154	.argc = 1,
		155	.argv = &desc_argv
		156	};
		157
1702	cejka	158	/* Data and methods for 'symaddr' command. */
596	jermar	159	static int cmd_symaddr(cmd_arg_t *argv);
		160	static char symaddr_buf[MAX_CMDLINE+1];
		161	static cmd_arg_t symaddr_argv = {
		162	.type = ARG_TYPE_STRING,
		163	.buffer = symaddr_buf,
		164	.len = sizeof(symaddr_buf)
		165	};
		166	static cmd_info_t symaddr_info = {
		167	.name = "symaddr",
		168	.description = "Return symbol address.",
		169	.func = cmd_symaddr,
		170	.argc = 1,
		171	.argv = &symaddr_argv
		172	};
		173
603	palkovsky	174	static char set_buf[MAX_CMDLINE+1];
		175	static int cmd_set4(cmd_arg_t *argv);
		176	static cmd_arg_t set4_argv[] = {
		177	{
		178	.type = ARG_TYPE_STRING,
		179	.buffer = set_buf,
		180	.len = sizeof(set_buf)
		181	},
		182	{
		183	.type = ARG_TYPE_INT
		184	}
		185	};
		186	static cmd_info_t set4_info = {
		187	.name = "set4",
		188	.description = "set <dest_addr> <value> - 4byte version",
		189	.func = cmd_set4,
		190	.argc = 2,
		191	.argv = set4_argv
		192	};
		193
1702	cejka	194	/* Data and methods for 'call0' command. */
596	jermar	195	static char call0_buf[MAX_CMDLINE+1];
		196	static char carg1_buf[MAX_CMDLINE+1];
		197	static char carg2_buf[MAX_CMDLINE+1];
		198	static char carg3_buf[MAX_CMDLINE+1];
		199
		200	static int cmd_call0(cmd_arg_t *argv);
		201	static cmd_arg_t call0_argv = {
		202	.type = ARG_TYPE_STRING,
		203	.buffer = call0_buf,
		204	.len = sizeof(call0_buf)
		205	};
		206	static cmd_info_t call0_info = {
		207	.name = "call0",
		208	.description = "call0 <function> -> call function().",
		209	.func = cmd_call0,
		210	.argc = 1,
		211	.argv = &call0_argv
		212	};
		213
1702	cejka	214	/* Data and methods for 'call1' command. */
596	jermar	215	static int cmd_call1(cmd_arg_t *argv);
		216	static cmd_arg_t call1_argv[] = {
		217	{
		218	.type = ARG_TYPE_STRING,
		219	.buffer = call0_buf,
		220	.len = sizeof(call0_buf)
		221	},
		222	{
		223	.type = ARG_TYPE_VAR,
		224	.buffer = carg1_buf,
		225	.len = sizeof(carg1_buf)
		226	}
		227	};
		228	static cmd_info_t call1_info = {
		229	.name = "call1",
		230	.description = "call1 <function> <arg1> -> call function(arg1).",
		231	.func = cmd_call1,
		232	.argc = 2,
		233	.argv = call1_argv
		234	};
		235
1702	cejka	236	/* Data and methods for 'call2' command. */
596	jermar	237	static int cmd_call2(cmd_arg_t *argv);
		238	static cmd_arg_t call2_argv[] = {
		239	{
		240	.type = ARG_TYPE_STRING,
		241	.buffer = call0_buf,
		242	.len = sizeof(call0_buf)
		243	},
		244	{
		245	.type = ARG_TYPE_VAR,
		246	.buffer = carg1_buf,
		247	.len = sizeof(carg1_buf)
		248	},
		249	{
		250	.type = ARG_TYPE_VAR,
		251	.buffer = carg2_buf,
		252	.len = sizeof(carg2_buf)
		253	}
		254	};
		255	static cmd_info_t call2_info = {
		256	.name = "call2",
		257	.description = "call2 <function> <arg1> <arg2> -> call function(arg1,arg2).",
		258	.func = cmd_call2,
		259	.argc = 3,
		260	.argv = call2_argv
		261	};
		262
1702	cejka	263	/* Data and methods for 'call3' command. */
596	jermar	264	static int cmd_call3(cmd_arg_t *argv);
		265	static cmd_arg_t call3_argv[] = {
		266	{
		267	.type = ARG_TYPE_STRING,
		268	.buffer = call0_buf,
		269	.len = sizeof(call0_buf)
		270	},
		271	{
		272	.type = ARG_TYPE_VAR,
		273	.buffer = carg1_buf,
		274	.len = sizeof(carg1_buf)
		275	},
		276	{
		277	.type = ARG_TYPE_VAR,
		278	.buffer = carg2_buf,
		279	.len = sizeof(carg2_buf)
		280	},
		281	{
		282	.type = ARG_TYPE_VAR,
		283	.buffer = carg3_buf,
		284	.len = sizeof(carg3_buf)
		285	}
		286
		287	};
		288	static cmd_info_t call3_info = {
		289	.name = "call3",
		290	.description = "call3 <function> <arg1> <arg2> <arg3> -> call function(arg1,arg2,arg3).",
		291	.func = cmd_call3,
		292	.argc = 4,
		293	.argv = call3_argv
		294	};
		295
1702	cejka	296	/* Data and methods for 'halt' command. */
596	jermar	297	static int cmd_halt(cmd_arg_t *argv);
		298	static cmd_info_t halt_info = {
		299	.name = "halt",
		300	.description = "Halt the kernel.",
		301	.func = cmd_halt,
		302	.argc = 0
		303	};
		304
1702	cejka	305	/* Data and methods for 'tlb' command. */
673	jermar	306	static int cmd_tlb(cmd_arg_t *argv);
		307	cmd_info_t tlb_info = {
		308	.name = "tlb",
596	jermar	309	.description = "Print TLB of current processor.",
		310	.help = NULL,
673	jermar	311	.func = cmd_tlb,
596	jermar	312	.argc = 0,
		313	.argv = NULL
		314	};
		315
777	palkovsky	316	static int cmd_threads(cmd_arg_t *argv);
		317	static cmd_info_t threads_info = {
		318	.name = "threads",
1695	jermar	319	.description = "List all threads.",
777	palkovsky	320	.func = cmd_threads,
		321	.argc = 0
		322	};
668	bondari	323
1060	palkovsky	324	static int cmd_tasks(cmd_arg_t *argv);
		325	static cmd_info_t tasks_info = {
		326	.name = "tasks",
1695	jermar	327	.description = "List all tasks.",
1060	palkovsky	328	.func = cmd_tasks,
		329	.argc = 0
		330	};
777	palkovsky	331
1060	palkovsky	332
775	palkovsky	333	static int cmd_sched(cmd_arg_t *argv);
		334	static cmd_info_t sched_info = {
		335	.name = "scheduler",
1695	jermar	336	.description = "List all scheduler information.",
775	palkovsky	337	.func = cmd_sched,
		338	.argc = 0
		339	};
		340
759	palkovsky	341	static int cmd_slabs(cmd_arg_t *argv);
		342	static cmd_info_t slabs_info = {
		343	.name = "slabs",
1695	jermar	344	.description = "List slab caches.",
759	palkovsky	345	.func = cmd_slabs,
		346	.argc = 0
		347	};
		348
1702	cejka	349	/* Data and methods for 'zones' command */
668	bondari	350	static int cmd_zones(cmd_arg_t *argv);
		351	static cmd_info_t zones_info = {
		352	.name = "zones",
		353	.description = "List of memory zones.",
		354	.func = cmd_zones,
		355	.argc = 0
		356	};
		357
1702	cejka	358	/* Data and methods for 'ipc_task' command */
1573	palkovsky	359	static int cmd_ipc_task(cmd_arg_t *argv);
		360	static cmd_arg_t ipc_task_argv = {
		361	.type = ARG_TYPE_INT,
		362	};
		363	static cmd_info_t ipc_task_info = {
		364	.name = "ipc_task",
1695	jermar	365	.description = "ipc_task <taskid> Show IPC information of given task.",
1573	palkovsky	366	.func = cmd_ipc_task,
		367	.argc = 1,
		368	.argv = &ipc_task_argv
		369	};
		370
1702	cejka	371	/* Data and methods for 'zone' command */
668	bondari	372	static int cmd_zone(cmd_arg_t *argv);
		373	static cmd_arg_t zone_argv = {
		374	.type = ARG_TYPE_INT,
		375	};
		376
		377	static cmd_info_t zone_info = {
		378	.name = "zone",
		379	.description = "Show memory zone structure.",
		380	.func = cmd_zone,
		381	.argc = 1,
		382	.argv = &zone_argv
		383	};
		384
1702	cejka	385	/* Data and methods for 'cpus' command. */
673	jermar	386	static int cmd_cpus(cmd_arg_t *argv);
		387	cmd_info_t cpus_info = {
		388	.name = "cpus",
		389	.description = "List all processors.",
		390	.help = NULL,
		391	.func = cmd_cpus,
		392	.argc = 0,
		393	.argv = NULL
		394	};
668	bondari	395
1702	cejka	396	/* Data and methods for 'version' command. */
673	jermar	397	static int cmd_version(cmd_arg_t *argv);
		398	cmd_info_t version_info = {
		399	.name = "version",
		400	.description = "Print version information.",
		401	.help = NULL,
		402	.func = cmd_version,
		403	.argc = 0,
		404	.argv = NULL
		405	};
668	bondari	406
775	palkovsky	407	static cmd_info_t *basic_commands[] = {
		408	&call0_info,
		409	&call1_info,
		410	&call2_info,
		411	&call3_info,
1474	palkovsky	412	&continue_info,
775	palkovsky	413	&cpus_info,
		414	&desc_info,
		415	&exit_info,
		416	&halt_info,
		417	&help_info,
1573	palkovsky	418	&ipc_task_info,
775	palkovsky	419	&set4_info,
		420	&slabs_info,
		421	&symaddr_info,
		422	&sched_info,
777	palkovsky	423	&threads_info,
1060	palkovsky	424	&tasks_info,
775	palkovsky	425	&tlb_info,
		426	&version_info,
		427	&zones_info,
		428	&zone_info,
2019	decky	429	#ifdef CONFIG_TEST
		430	&tests_info,
		431	&test_info,
2050	decky	432	&bench_info,
2019	decky	433	#endif
775	palkovsky	434	NULL
		435	};
673	jermar	436
		437
596	jermar	438	/** Initialize command info structure.
		439	*
		440	* @param cmd Command info structure.
		441	*
		442	*/
		443	void cmd_initialize(cmd_info_t *cmd)
		444	{
		445	spinlock_initialize(&cmd->lock, "cmd");
		446	link_initialize(&cmd->link);
		447	}
		448
		449	/** Initialize and register commands. */
		450	void cmd_init(void)
		451	{
775	palkovsky	452	int i;
596	jermar	453
775	palkovsky	454	for (i=0;basic_commands[i]; i++) {
		455	cmd_initialize(basic_commands[i]);
		456	if (!cmd_register(basic_commands[i]))
		457	panic("could not register command %s\n",
		458	basic_commands[i]->name);
		459	}
596	jermar	460	}
		461
		462
		463	/** List supported commands.
		464	*
		465	* @param argv Argument vector.
		466	*
		467	* @return 0 on failure, 1 on success.
		468	*/
		469	int cmd_help(cmd_arg_t *argv)
		470	{
		471	link_t *cur;
		472
		473	spinlock_lock(&cmd_lock);
		474
		475	for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
		476	cmd_info_t *hlp;
		477
		478	hlp = list_get_instance(cur, cmd_info_t, link);
		479	spinlock_lock(&hlp->lock);
		480
		481	printf("%s - %s\n", hlp->name, hlp->description);
		482
		483	spinlock_unlock(&hlp->lock);
		484	}
		485
		486	spinlock_unlock(&cmd_lock);
		487
		488	return 1;
		489	}
		490
		491	/** Describe specified command.
		492	*
		493	* @param argv Argument vector.
		494	*
		495	* @return 0 on failure, 1 on success.
		496	*/
		497	int cmd_desc(cmd_arg_t *argv)
		498	{
		499	link_t *cur;
		500
		501	spinlock_lock(&cmd_lock);
		502
		503	for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
		504	cmd_info_t *hlp;
		505
		506	hlp = list_get_instance(cur, cmd_info_t, link);
		507	spinlock_lock(&hlp->lock);
		508
		509	if (strncmp(hlp->name, (const char *) argv->buffer, strlen(hlp->name)) == 0) {
		510	printf("%s - %s\n", hlp->name, hlp->description);
		511	if (hlp->help)
		512	hlp->help();
		513	spinlock_unlock(&hlp->lock);
		514	break;
		515	}
		516
		517	spinlock_unlock(&hlp->lock);
		518	}
		519
		520	spinlock_unlock(&cmd_lock);
		521
		522	return 1;
		523	}
		524
		525	/** Search symbol table */
		526	int cmd_symaddr(cmd_arg_t *argv)
		527	{
2114	decky	528	symtab_print_search((char *) argv->buffer);
596	jermar	529
		530	return 1;
		531	}
		532
		533	/** Call function with zero parameters */
		534	int cmd_call0(cmd_arg_t *argv)
		535	{
1780	jermar	536	uintptr_t symaddr;
596	jermar	537	char *symbol;
1780	jermar	538	unative_t (*f)(void);
1666	palkovsky	539	#ifdef ia64
		540	struct {
1780	jermar	541	unative_t f;
		542	unative_t gp;
1666	palkovsky	543	}fptr;
		544	#endif
596	jermar	545
2114	decky	546	symaddr = get_symbol_addr((char *) argv->buffer);
596	jermar	547	if (!symaddr)
		548	printf("Symbol %s not found.\n", argv->buffer);
1780	jermar	549	else if (symaddr == (uintptr_t) -1) {
2114	decky	550	symtab_print_search((char *) argv->buffer);
596	jermar	551	printf("Duplicate symbol, be more specific.\n");
		552	} else {
		553	symbol = get_symtab_entry(symaddr);
1780	jermar	554	printf("Calling f(): %.p: %s\n", sizeof(uintptr_t) 2, symaddr, symbol);
1666	palkovsky	555	#ifdef ia64
		556	fptr.f = symaddr;
1780	jermar	557	fptr.gp = ((unative_t *)cmd_call2)[1];
		558	f = (unative_t (*)(void)) &fptr;
1666	palkovsky	559	#else
1780	jermar	560	f = (unative_t (*)(void)) symaddr;
1666	palkovsky	561	#endif
1224	cejka	562	printf("Result: %#zx\n", f());
596	jermar	563	}
		564
		565	return 1;
		566	}
		567
		568	/** Call function with one parameter */
		569	int cmd_call1(cmd_arg_t *argv)
		570	{
1780	jermar	571	uintptr_t symaddr;
596	jermar	572	char *symbol;
1780	jermar	573	unative_t (*f)(unative_t,...);
		574	unative_t arg1 = argv[1].intval;
1666	palkovsky	575	#ifdef ia64
		576	struct {
1780	jermar	577	unative_t f;
		578	unative_t gp;
1666	palkovsky	579	}fptr;
		580	#endif
596	jermar	581
2114	decky	582	symaddr = get_symbol_addr((char *) argv->buffer);
596	jermar	583	if (!symaddr)
		584	printf("Symbol %s not found.\n", argv->buffer);
1780	jermar	585	else if (symaddr == (uintptr_t) -1) {
2114	decky	586	symtab_print_search((char *) argv->buffer);
596	jermar	587	printf("Duplicate symbol, be more specific.\n");
		588	} else {
		589	symbol = get_symtab_entry(symaddr);
1666	palkovsky	590
1780	jermar	591	printf("Calling f(%#zx): %.p: %s\n", arg1, sizeof(uintptr_t) 2, symaddr, symbol);
1666	palkovsky	592	#ifdef ia64
		593	fptr.f = symaddr;
1780	jermar	594	fptr.gp = ((unative_t *)cmd_call2)[1];
		595	f = (unative_t (*)(unative_t,...)) &fptr;
1666	palkovsky	596	#else
1780	jermar	597	f = (unative_t (*)(unative_t,...)) symaddr;
1666	palkovsky	598	#endif
1224	cejka	599	printf("Result: %#zx\n", f(arg1));
596	jermar	600	}
		601
		602	return 1;
		603	}
		604
		605	/** Call function with two parameters */
		606	int cmd_call2(cmd_arg_t *argv)
		607	{
1780	jermar	608	uintptr_t symaddr;
596	jermar	609	char *symbol;
1780	jermar	610	unative_t (*f)(unative_t,unative_t,...);
		611	unative_t arg1 = argv[1].intval;
		612	unative_t arg2 = argv[2].intval;
1666	palkovsky	613	#ifdef ia64
		614	struct {
1780	jermar	615	unative_t f;
		616	unative_t gp;
1666	palkovsky	617	}fptr;
		618	#endif
596	jermar	619
2114	decky	620	symaddr = get_symbol_addr((char *) argv->buffer);
596	jermar	621	if (!symaddr)
		622	printf("Symbol %s not found.\n", argv->buffer);
1780	jermar	623	else if (symaddr == (uintptr_t) -1) {
2114	decky	624	symtab_print_search((char *) argv->buffer);
596	jermar	625	printf("Duplicate symbol, be more specific.\n");
		626	} else {
		627	symbol = get_symtab_entry(symaddr);
1224	cejka	628	printf("Calling f(0x%zx,0x%zx): %.*p: %s\n",
1780	jermar	629	arg1, arg2, sizeof(uintptr_t) * 2, symaddr, symbol);
1666	palkovsky	630	#ifdef ia64
		631	fptr.f = symaddr;
1780	jermar	632	fptr.gp = ((unative_t *)cmd_call2)[1];
		633	f = (unative_t (*)(unative_t,unative_t,...)) &fptr;
1666	palkovsky	634	#else
1780	jermar	635	f = (unative_t (*)(unative_t,unative_t,...)) symaddr;
1666	palkovsky	636	#endif
1224	cejka	637	printf("Result: %#zx\n", f(arg1, arg2));
596	jermar	638	}
		639
		640	return 1;
		641	}
		642
		643	/** Call function with three parameters */
		644	int cmd_call3(cmd_arg_t *argv)
		645	{
1780	jermar	646	uintptr_t symaddr;
596	jermar	647	char *symbol;
1780	jermar	648	unative_t (*f)(unative_t,unative_t,unative_t,...);
		649	unative_t arg1 = argv[1].intval;
		650	unative_t arg2 = argv[2].intval;
		651	unative_t arg3 = argv[3].intval;
1666	palkovsky	652	#ifdef ia64
		653	struct {
1780	jermar	654	unative_t f;
		655	unative_t gp;
1666	palkovsky	656	}fptr;
		657	#endif
596	jermar	658
2114	decky	659	symaddr = get_symbol_addr((char *) argv->buffer);
596	jermar	660	if (!symaddr)
		661	printf("Symbol %s not found.\n", argv->buffer);
1780	jermar	662	else if (symaddr == (uintptr_t) -1) {
2114	decky	663	symtab_print_search((char *) argv->buffer);
596	jermar	664	printf("Duplicate symbol, be more specific.\n");
		665	} else {
		666	symbol = get_symtab_entry(symaddr);
1224	cejka	667	printf("Calling f(0x%zx,0x%zx, 0x%zx): %.*p: %s\n",
1780	jermar	668	arg1, arg2, arg3, sizeof(uintptr_t) * 2, symaddr, symbol);
1666	palkovsky	669	#ifdef ia64
		670	fptr.f = symaddr;
1780	jermar	671	fptr.gp = ((unative_t *)cmd_call2)[1];
		672	f = (unative_t (*)(unative_t,unative_t,unative_t,...)) &fptr;
1666	palkovsky	673	#else
1780	jermar	674	f = (unative_t (*)(unative_t,unative_t,unative_t,...)) symaddr;
1666	palkovsky	675	#endif
1224	cejka	676	printf("Result: %#zx\n", f(arg1, arg2, arg3));
596	jermar	677	}
		678
		679	return 1;
		680	}
		681
		682
		683	/** Print detailed description of 'describe' command. */
		684	void desc_help(void)
		685	{
		686	printf("Syntax: describe command_name\n");
		687	}
		688
		689	/** Halt the kernel.
		690	*
		691	* @param argv Argument vector (ignored).
		692	*
		693	* @return 0 on failure, 1 on success (never returns).
		694	*/
		695	int cmd_halt(cmd_arg_t *argv)
		696	{
		697	halt();
		698	return 1;
		699	}
		700
		701	/** Command for printing TLB contents.
		702	*
		703	* @param argv Not used.
		704	*
		705	* @return Always returns 1.
		706	*/
673	jermar	707	int cmd_tlb(cmd_arg_t *argv)
596	jermar	708	{
		709	tlb_print();
		710	return 1;
		711	}
603	palkovsky	712
		713	/** Write 4 byte value to address */
		714	int cmd_set4(cmd_arg_t *argv)
		715	{
1780	jermar	716	uint32_t *addr ;
		717	uint32_t arg1 = argv[1].intval;
603	palkovsky	718	bool pointer = false;
		719
		720	if (((char )argv->buffer)[0] == '') {
2114	decky	721	addr = (uint32_t ) get_symbol_addr((char ) argv->buffer + 1);
603	palkovsky	722	pointer = true;
2114	decky	723	} else if (((char *) argv->buffer)[0] >= '0' &&
603	palkovsky	724	((char *)argv->buffer)[0] <= '9')
1780	jermar	725	addr = (uint32_t )atoi((char )argv->buffer);
603	palkovsky	726	else
2114	decky	727	addr = (uint32_t )get_symbol_addr((char ) argv->buffer);
603	palkovsky	728
		729	if (!addr)
		730	printf("Symbol %s not found.\n", argv->buffer);
1780	jermar	731	else if (addr == (uint32_t *) -1) {
2114	decky	732	symtab_print_search((char *) argv->buffer);
603	palkovsky	733	printf("Duplicate symbol, be more specific.\n");
		734	} else {
		735	if (pointer)
1780	jermar	736	addr = (uint32_t )((unative_t *)addr);
		737	printf("Writing 0x%x -> %.p\n", arg1, sizeof(uintptr_t) 2, addr);
603	palkovsky	738	*addr = arg1;
		739
		740	}
		741
		742	return 1;
		743	}
668	bondari	744
759	palkovsky	745	/** Command for listings SLAB caches
		746	*
		747	* @param argv Ignores
		748	*
		749	* @return Always 1
		750	*/
		751	int cmd_slabs(cmd_arg_t * argv) {
		752	slab_print_list();
		753	return 1;
		754	}
		755
777	palkovsky	756
775	palkovsky	757	/** Command for listings Thread information
		758	*
		759	* @param argv Ignores
		760	*
		761	* @return Always 1
		762	*/
777	palkovsky	763	int cmd_threads(cmd_arg_t * argv) {
		764	thread_print_list();
		765	return 1;
		766	}
		767
1060	palkovsky	768	/** Command for listings Task information
		769	*
		770	* @param argv Ignores
		771	*
		772	* @return Always 1
		773	*/
		774	int cmd_tasks(cmd_arg_t * argv) {
		775	task_print_list();
		776	return 1;
		777	}
		778
777	palkovsky	779	/** Command for listings Thread information
		780	*
		781	* @param argv Ignores
		782	*
		783	* @return Always 1
		784	*/
775	palkovsky	785	int cmd_sched(cmd_arg_t * argv) {
		786	sched_print_list();
		787	return 1;
		788	}
		789
677	bondari	790	/** Command for listing memory zones
		791	*
		792	* @param argv Ignored
		793	*
		794	* return Always 1
		795	*/
668	bondari	796	int cmd_zones(cmd_arg_t * argv) {
676	bondari	797	zone_print_list();
668	bondari	798	return 1;
		799	}
673	jermar	800
677	bondari	801	/** Command for memory zone details
		802	*
		803	* @param argv Integer argument from cmdline expected
		804	*
		805	* return Always 1
		806	*/
668	bondari	807	int cmd_zone(cmd_arg_t * argv) {
676	bondari	808	zone_print_one(argv[0].intval);
668	bondari	809	return 1;
		810	}
		811
1573	palkovsky	812	/** Command for printing task ipc details
		813	*
		814	* @param argv Integer argument from cmdline expected
		815	*
		816	* return Always 1
		817	*/
		818	int cmd_ipc_task(cmd_arg_t * argv) {
		819	ipc_print_task(argv[0].intval);
		820	return 1;
		821	}
		822
		823
673	jermar	824	/** Command for listing processors.
		825	*
		826	* @param argv Ignored.
		827	*
		828	* return Always 1.
		829	*/
		830	int cmd_cpus(cmd_arg_t *argv)
		831	{
		832	cpu_list();
		833	return 1;
		834	}
		835
		836	/** Command for printing kernel version.
		837	*
		838	* @param argv Ignored.
		839	*
		840	* return Always 1.
		841	*/
		842	int cmd_version(cmd_arg_t *argv)
		843	{
		844	version_print();
		845	return 1;
		846	}
1474	palkovsky	847
		848	/** Command for returning console back to userspace.
		849	*
		850	* @param argv Ignored.
		851	*
		852	* return Always 1.
		853	*/
		854	int cmd_continue(cmd_arg_t *argv)
		855	{
1695	jermar	856	printf("The kernel will now relinquish the console.\n");
		857	printf("Use userspace controls to redraw the screen.\n");
1474	palkovsky	858	arch_release_console();
		859	return 1;
		860	}
1702	cejka	861
2020	decky	862	#ifdef CONFIG_TEST
2019	decky	863	/** Command for printing kernel tests list.
		864	*
		865	* @param argv Ignored.
		866	*
		867	* return Always 1.
		868	*/
		869	int cmd_tests(cmd_arg_t *argv)
		870	{
		871	test_t *test;
		872
		873	for (test = tests; test->name != NULL; test++)
2020	decky	874	printf("%s\t\t%s%s\n", test->name, test->desc, (test->safe ? "" : " (unsafe)"));
2019	decky	875
2020	decky	876	printf("*\t\tRun all safe tests\n");
2019	decky	877	return 1;
		878	}
		879
2042	decky	880	static bool run_test(const test_t *test)
2027	decky	881	{
2042	decky	882	printf("%s\t\t%s\n", test->name, test->desc);
2030	decky	883
		884	/* Update and read thread accounting
		885	for benchmarking */
		886	ipl_t ipl = interrupts_disable();
2039	decky	887	spinlock_lock(&TASK->lock);
		888	uint64_t t0 = task_get_accounting(TASK);
		889	spinlock_unlock(&TASK->lock);
2030	decky	890	interrupts_restore(ipl);
		891
		892	/* Execute the test */
2050	decky	893	char * ret = test->entry(false);
2030	decky	894
		895	/* Update and read thread accounting */
		896	ipl = interrupts_disable();
2039	decky	897	spinlock_lock(&TASK->lock);
		898	uint64_t dt = task_get_accounting(TASK) - t0;
		899	spinlock_unlock(&TASK->lock);
2030	decky	900	interrupts_restore(ipl);
		901
2050	decky	902	uint64_t cycles;
		903	char suffix;
		904	order(dt, &cycles, &suffix);
		905
		906	printf("Time: %llu%c cycles\n", cycles, suffix);
2027	decky	907
		908	if (ret == NULL) {
		909	printf("Test passed\n");
2042	decky	910	return true;
2027	decky	911	}
		912
		913	printf("%s\n", ret);
2042	decky	914	return false;
2027	decky	915	}
		916
2050	decky	917	static bool run_bench(const test_t *test, const uint32_t cnt)
		918	{
		919	uint32_t i;
		920	bool ret = true;
		921	uint64_t cycles;
		922	char suffix;
		923
		924	if (cnt < 1)
		925	return true;
		926
2114	decky	927	uint64_t data = (uint64_t ) malloc(sizeof(uint64_t) * cnt, 0);
2050	decky	928	if (data == NULL) {
		929	printf("Error allocating memory for statistics\n");
		930	return false;
		931	}
		932
		933	for (i = 0; i < cnt; i++) {
		934	printf("%s (%d/%d) ... ", test->name, i + 1, cnt);
		935
		936	/* Update and read thread accounting
		937	for benchmarking */
		938	ipl_t ipl = interrupts_disable();
		939	spinlock_lock(&TASK->lock);
		940	uint64_t t0 = task_get_accounting(TASK);
		941	spinlock_unlock(&TASK->lock);
		942	interrupts_restore(ipl);
		943
		944	/* Execute the test */
		945	char * ret = test->entry(true);
		946
		947	/* Update and read thread accounting */
		948	ipl = interrupts_disable();
		949	spinlock_lock(&TASK->lock);
		950	uint64_t dt = task_get_accounting(TASK) - t0;
		951	spinlock_unlock(&TASK->lock);
		952	interrupts_restore(ipl);
		953
		954	if (ret != NULL) {
		955	printf("%s\n", ret);
		956	ret = false;
		957	break;
		958	}
		959
		960	data[i] = dt;
		961	order(dt, &cycles, &suffix);
		962	printf("OK (%llu%c cycles)\n", cycles, suffix);
		963	}
		964
		965	if (ret) {
		966	printf("\n");
		967
		968	uint64_t sum = 0;
		969
		970	for (i = 0; i < cnt; i++) {
		971	sum += data[i];
		972	}
		973
		974	order(sum / (uint64_t) cnt, &cycles, &suffix);
		975	printf("Average\t\t%llu%c\n", cycles, suffix);
		976	}
		977
		978	free(data);
		979
		980	return ret;
		981	}
		982
2019	decky	983	/** Command for returning kernel tests
		984	*
		985	* @param argv Argument vector.
		986	*
		987	* return Always 1.
		988	*/
		989	int cmd_test(cmd_arg_t *argv)
		990	{
		991	test_t *test;
		992
2114	decky	993	if (strcmp((char ) argv->buffer, "") == 0) {
2020	decky	994	for (test = tests; test->name != NULL; test++) {
		995	if (test->safe) {
2027	decky	996	printf("\n");
		997	if (!run_test(test))
		998	break;
2020	decky	999	}
2019	decky	1000	}
2020	decky	1001	} else {
		1002	bool fnd = false;
		1003
		1004	for (test = tests; test->name != NULL; test++) {
2114	decky	1005	if (strcmp(test->name, (char *) argv->buffer) == 0) {
2020	decky	1006	fnd = true;
2027	decky	1007	run_test(test);
2020	decky	1008	break;
		1009	}
		1010	}
		1011
		1012	if (!fnd)
2027	decky	1013	printf("Unknown test\n");
2019	decky	1014	}
		1015
		1016	return 1;
		1017	}
2050	decky	1018
		1019	/** Command for returning kernel tests as benchmarks
		1020	*
		1021	* @param argv Argument vector.
		1022	*
		1023	* return Always 1.
		1024	*/
		1025	int cmd_bench(cmd_arg_t *argv)
		1026	{
		1027	test_t *test;
		1028	uint32_t cnt = argv[1].intval;
		1029
		1030	bool fnd = false;
		1031
		1032	for (test = tests; test->name != NULL; test++) {
2114	decky	1033	if (strcmp(test->name, (char *) argv->buffer) == 0) {
2050	decky	1034	fnd = true;
2051	decky	1035
		1036	if (test->safe)
		1037	run_bench(test, cnt);
		1038	else
		1039	printf("Unsafe test\n");
		1040
2050	decky	1041	break;
		1042	}
		1043	}
		1044
		1045	if (!fnd)
		1046	printf("Unknown test\n");
		1047
		1048	return 1;
		1049	}
		1050
2020	decky	1051	#endif
2019	decky	1052
1888	jermar	1053	/** @}
1702	cejka	1054	*/

Subversion Repositories HelenOS

(root)/trunk/kernel/generic/src/console/cmd.c – Rev 2114