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

Subversion Repositories HelenOS

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