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
2721	decky	337	/* Data and methods for 'physmem' command. */
		338	static int cmd_physmem(cmd_arg_t *argv);
		339	cmd_info_t physmem_info = {
		340	.name = "physmem",
		341	.description = "Print physical memory configuration.",
		342	.help = NULL,
		343	.func = cmd_physmem,
		344	.argc = 0,
		345	.argv = NULL
		346	};
		347
1702	cejka	348	/* Data and methods for 'tlb' command. */
673	jermar	349	static int cmd_tlb(cmd_arg_t *argv);
		350	cmd_info_t tlb_info = {
		351	.name = "tlb",
596	jermar	352	.description = "Print TLB of current processor.",
		353	.help = NULL,
673	jermar	354	.func = cmd_tlb,
596	jermar	355	.argc = 0,
		356	.argv = NULL
		357	};
		358
777	palkovsky	359	static int cmd_threads(cmd_arg_t *argv);
		360	static cmd_info_t threads_info = {
		361	.name = "threads",
1695	jermar	362	.description = "List all threads.",
777	palkovsky	363	.func = cmd_threads,
		364	.argc = 0
		365	};
668	bondari	366
1060	palkovsky	367	static int cmd_tasks(cmd_arg_t *argv);
		368	static cmd_info_t tasks_info = {
		369	.name = "tasks",
1695	jermar	370	.description = "List all tasks.",
1060	palkovsky	371	.func = cmd_tasks,
		372	.argc = 0
		373	};
777	palkovsky	374
1060	palkovsky	375
775	palkovsky	376	static int cmd_sched(cmd_arg_t *argv);
		377	static cmd_info_t sched_info = {
		378	.name = "scheduler",
1695	jermar	379	.description = "List all scheduler information.",
775	palkovsky	380	.func = cmd_sched,
		381	.argc = 0
		382	};
		383
759	palkovsky	384	static int cmd_slabs(cmd_arg_t *argv);
		385	static cmd_info_t slabs_info = {
		386	.name = "slabs",
1695	jermar	387	.description = "List slab caches.",
759	palkovsky	388	.func = cmd_slabs,
		389	.argc = 0
		390	};
		391
1702	cejka	392	/* Data and methods for 'zones' command */
668	bondari	393	static int cmd_zones(cmd_arg_t *argv);
		394	static cmd_info_t zones_info = {
		395	.name = "zones",
		396	.description = "List of memory zones.",
		397	.func = cmd_zones,
		398	.argc = 0
		399	};
		400
3451	jermar	401	/* Data and methods for 'ipc' command */
		402	static int cmd_ipc(cmd_arg_t *argv);
		403	static cmd_arg_t ipc_argv = {
1573	palkovsky	404	.type = ARG_TYPE_INT,
		405	};
3451	jermar	406	static cmd_info_t ipc_info = {
		407	.name = "ipc",
		408	.description = "ipc <taskid> Show IPC information of given task.",
		409	.func = cmd_ipc,
1573	palkovsky	410	.argc = 1,
3451	jermar	411	.argv = &ipc_argv
1573	palkovsky	412	};
		413
1702	cejka	414	/* Data and methods for 'zone' command */
668	bondari	415	static int cmd_zone(cmd_arg_t *argv);
		416	static cmd_arg_t zone_argv = {
		417	.type = ARG_TYPE_INT,
		418	};
		419
		420	static cmd_info_t zone_info = {
		421	.name = "zone",
		422	.description = "Show memory zone structure.",
		423	.func = cmd_zone,
		424	.argc = 1,
		425	.argv = &zone_argv
		426	};
		427
1702	cejka	428	/* Data and methods for 'cpus' command. */
673	jermar	429	static int cmd_cpus(cmd_arg_t *argv);
		430	cmd_info_t cpus_info = {
		431	.name = "cpus",
		432	.description = "List all processors.",
		433	.help = NULL,
		434	.func = cmd_cpus,
		435	.argc = 0,
		436	.argv = NULL
		437	};
668	bondari	438
1702	cejka	439	/* Data and methods for 'version' command. */
673	jermar	440	static int cmd_version(cmd_arg_t *argv);
		441	cmd_info_t version_info = {
		442	.name = "version",
		443	.description = "Print version information.",
		444	.help = NULL,
		445	.func = cmd_version,
		446	.argc = 0,
		447	.argv = NULL
		448	};
668	bondari	449
775	palkovsky	450	static cmd_info_t *basic_commands[] = {
		451	&call0_info,
2223	decky	452	&mcall0_info,
775	palkovsky	453	&call1_info,
		454	&call2_info,
		455	&call3_info,
1474	palkovsky	456	&continue_info,
775	palkovsky	457	&cpus_info,
		458	&desc_info,
		459	&exit_info,
2227	decky	460	&reboot_info,
2275	decky	461	&uptime_info,
775	palkovsky	462	&halt_info,
		463	&help_info,
3451	jermar	464	&ipc_info,
775	palkovsky	465	&set4_info,
		466	&slabs_info,
		467	&symaddr_info,
		468	&sched_info,
777	palkovsky	469	&threads_info,
1060	palkovsky	470	&tasks_info,
2721	decky	471	&physmem_info,
775	palkovsky	472	&tlb_info,
		473	&version_info,
		474	&zones_info,
		475	&zone_info,
2019	decky	476	#ifdef CONFIG_TEST
		477	&tests_info,
		478	&test_info,
2050	decky	479	&bench_info,
2019	decky	480	#endif
775	palkovsky	481	NULL
		482	};
673	jermar	483
		484
596	jermar	485	/** Initialize command info structure.
		486	*
		487	* @param cmd Command info structure.
		488	*
		489	*/
		490	void cmd_initialize(cmd_info_t *cmd)
		491	{
		492	spinlock_initialize(&cmd->lock, "cmd");
		493	link_initialize(&cmd->link);
		494	}
		495
		496	/** Initialize and register commands. */
		497	void cmd_init(void)
		498	{
2721	decky	499	unsigned int i;
596	jermar	500
2721	decky	501	for (i = 0; basic_commands[i]; i++) {
775	palkovsky	502	cmd_initialize(basic_commands[i]);
		503	if (!cmd_register(basic_commands[i]))
2721	decky	504	panic("could not register command %s\n", basic_commands[i]->name);
775	palkovsky	505	}
596	jermar	506	}
		507
		508
		509	/** List supported commands.
		510	*
		511	* @param argv Argument vector.
		512	*
		513	* @return 0 on failure, 1 on success.
		514	*/
		515	int cmd_help(cmd_arg_t *argv)
		516	{
		517	link_t *cur;
		518
		519	spinlock_lock(&cmd_lock);
		520
		521	for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
		522	cmd_info_t *hlp;
		523
		524	hlp = list_get_instance(cur, cmd_info_t, link);
		525	spinlock_lock(&hlp->lock);
		526
		527	printf("%s - %s\n", hlp->name, hlp->description);
		528
		529	spinlock_unlock(&hlp->lock);
		530	}
		531
		532	spinlock_unlock(&cmd_lock);
		533
		534	return 1;
		535	}
		536
2227	decky	537
		538	/** Reboot the system.
		539	*
		540	* @param argv Argument vector.
		541	*
		542	* @return 0 on failure, 1 on success.
		543	*/
		544	int cmd_reboot(cmd_arg_t *argv)
		545	{
		546	reboot();
		547
		548	/* Not reached */
		549	return 1;
		550	}
		551
2275	decky	552
		553	/** Print system uptime information.
		554	*
		555	* @param argv Argument vector.
		556	*
		557	* @return 0 on failure, 1 on success.
		558	*/
		559	int cmd_uptime(cmd_arg_t *argv)
		560	{
		561	ASSERT(uptime);
		562
		563	/* This doesn't have to be very accurate */
		564	unative_t sec = uptime->seconds1;
		565
3065	decky	566	printf("Up %" PRIun " days, %" PRIun " hours, %" PRIun " minutes, %" PRIun " seconds\n",
2275	decky	567	sec / 86400, (sec % 86400) / 3600, (sec % 3600) / 60, sec % 60);
		568
		569	return 1;
		570	}
		571
596	jermar	572	/** Describe specified command.
		573	*
		574	* @param argv Argument vector.
		575	*
		576	* @return 0 on failure, 1 on success.
		577	*/
		578	int cmd_desc(cmd_arg_t *argv)
		579	{
		580	link_t *cur;
		581
		582	spinlock_lock(&cmd_lock);
		583
		584	for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
		585	cmd_info_t *hlp;
		586
		587	hlp = list_get_instance(cur, cmd_info_t, link);
		588	spinlock_lock(&hlp->lock);
		589
		590	if (strncmp(hlp->name, (const char *) argv->buffer, strlen(hlp->name)) == 0) {
		591	printf("%s - %s\n", hlp->name, hlp->description);
		592	if (hlp->help)
		593	hlp->help();
		594	spinlock_unlock(&hlp->lock);
		595	break;
		596	}
		597
		598	spinlock_unlock(&hlp->lock);
		599	}
		600
		601	spinlock_unlock(&cmd_lock);
		602
		603	return 1;
		604	}
		605
		606	/** Search symbol table */
		607	int cmd_symaddr(cmd_arg_t *argv)
		608	{
2114	decky	609	symtab_print_search((char *) argv->buffer);
596	jermar	610
		611	return 1;
		612	}
		613
		614	/** Call function with zero parameters */
		615	int cmd_call0(cmd_arg_t *argv)
		616	{
1780	jermar	617	uintptr_t symaddr;
596	jermar	618	char *symbol;
1780	jermar	619	unative_t (*f)(void);
1666	palkovsky	620	#ifdef ia64
		621	struct {
1780	jermar	622	unative_t f;
		623	unative_t gp;
2223	decky	624	} fptr;
1666	palkovsky	625	#endif
596	jermar	626
2114	decky	627	symaddr = get_symbol_addr((char *) argv->buffer);
596	jermar	628	if (!symaddr)
		629	printf("Symbol %s not found.\n", argv->buffer);
1780	jermar	630	else if (symaddr == (uintptr_t) -1) {
2114	decky	631	symtab_print_search((char *) argv->buffer);
596	jermar	632	printf("Duplicate symbol, be more specific.\n");
		633	} else {
		634	symbol = get_symtab_entry(symaddr);
3065	decky	635	printf("Calling %s() (%p)\n", symbol, symaddr);
1666	palkovsky	636	#ifdef ia64
		637	fptr.f = symaddr;
1780	jermar	638	fptr.gp = ((unative_t *)cmd_call2)[1];
		639	f = (unative_t (*)(void)) &fptr;
1666	palkovsky	640	#else
1780	jermar	641	f = (unative_t (*)(void)) symaddr;
1666	palkovsky	642	#endif
3065	decky	643	printf("Result: %#" PRIxn "\n", f());
596	jermar	644	}
		645
		646	return 1;
		647	}
		648
2223	decky	649	/** Call function with zero parameters on each CPU */
		650	int cmd_mcall0(cmd_arg_t *argv)
		651	{
		652	/*
		653	* For each CPU, create a thread which will
		654	* call the function.
		655	*/
		656
		657	count_t i;
		658	for (i = 0; i < config.cpu_count; i++) {
2319	decky	659	if (!cpus[i].active)
		660	continue;
		661
2223	decky	662	thread_t *t;
		663	if ((t = thread_create((void ()(void )) cmd_call0, (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
		664	spinlock_lock(&t->lock);
		665	t->cpu = &cpus[i];
		666	spinlock_unlock(&t->lock);
		667	printf("cpu%u: ", i);
		668	thread_ready(t);
		669	thread_join(t);
2224	decky	670	thread_detach(t);
2223	decky	671	} else
		672	printf("Unable to create thread for cpu%u\n", i);
		673	}
		674
		675	return 1;
		676	}
		677
596	jermar	678	/** Call function with one parameter */
		679	int cmd_call1(cmd_arg_t *argv)
		680	{
1780	jermar	681	uintptr_t symaddr;
596	jermar	682	char *symbol;
1780	jermar	683	unative_t (*f)(unative_t,...);
		684	unative_t arg1 = argv[1].intval;
1666	palkovsky	685	#ifdef ia64
		686	struct {
1780	jermar	687	unative_t f;
		688	unative_t gp;
3065	decky	689	} fptr;
1666	palkovsky	690	#endif
596	jermar	691
2114	decky	692	symaddr = get_symbol_addr((char *) argv->buffer);
596	jermar	693	if (!symaddr)
		694	printf("Symbol %s not found.\n", argv->buffer);
1780	jermar	695	else if (symaddr == (uintptr_t) -1) {
2114	decky	696	symtab_print_search((char *) argv->buffer);
596	jermar	697	printf("Duplicate symbol, be more specific.\n");
		698	} else {
		699	symbol = get_symtab_entry(symaddr);
1666	palkovsky	700
3065	decky	701	printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
1666	palkovsky	702	#ifdef ia64
		703	fptr.f = symaddr;
1780	jermar	704	fptr.gp = ((unative_t *)cmd_call2)[1];
		705	f = (unative_t (*)(unative_t,...)) &fptr;
1666	palkovsky	706	#else
1780	jermar	707	f = (unative_t (*)(unative_t,...)) symaddr;
1666	palkovsky	708	#endif
3065	decky	709	printf("Result: %#" PRIxn "\n", f(arg1));
596	jermar	710	}
		711
		712	return 1;
		713	}
		714
		715	/** Call function with two parameters */
		716	int cmd_call2(cmd_arg_t *argv)
		717	{
1780	jermar	718	uintptr_t symaddr;
596	jermar	719	char *symbol;
1780	jermar	720	unative_t (*f)(unative_t,unative_t,...);
		721	unative_t arg1 = argv[1].intval;
		722	unative_t arg2 = argv[2].intval;
1666	palkovsky	723	#ifdef ia64
		724	struct {
1780	jermar	725	unative_t f;
		726	unative_t gp;
1666	palkovsky	727	}fptr;
		728	#endif
596	jermar	729
2114	decky	730	symaddr = get_symbol_addr((char *) argv->buffer);
596	jermar	731	if (!symaddr)
		732	printf("Symbol %s not found.\n", argv->buffer);
1780	jermar	733	else if (symaddr == (uintptr_t) -1) {
2114	decky	734	symtab_print_search((char *) argv->buffer);
596	jermar	735	printf("Duplicate symbol, be more specific.\n");
		736	} else {
		737	symbol = get_symtab_entry(symaddr);
3065	decky	738	printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
		739	arg1, arg2, symaddr, symbol);
1666	palkovsky	740	#ifdef ia64
		741	fptr.f = symaddr;
1780	jermar	742	fptr.gp = ((unative_t *)cmd_call2)[1];
		743	f = (unative_t (*)(unative_t,unative_t,...)) &fptr;
1666	palkovsky	744	#else
1780	jermar	745	f = (unative_t (*)(unative_t,unative_t,...)) symaddr;
1666	palkovsky	746	#endif
3065	decky	747	printf("Result: %#" PRIxn "\n", f(arg1, arg2));
596	jermar	748	}
		749
		750	return 1;
		751	}
		752
		753	/** Call function with three parameters */
		754	int cmd_call3(cmd_arg_t *argv)
		755	{
1780	jermar	756	uintptr_t symaddr;
596	jermar	757	char *symbol;
1780	jermar	758	unative_t (*f)(unative_t,unative_t,unative_t,...);
		759	unative_t arg1 = argv[1].intval;
		760	unative_t arg2 = argv[2].intval;
		761	unative_t arg3 = argv[3].intval;
1666	palkovsky	762	#ifdef ia64
		763	struct {
1780	jermar	764	unative_t f;
		765	unative_t gp;
1666	palkovsky	766	}fptr;
		767	#endif
596	jermar	768
2114	decky	769	symaddr = get_symbol_addr((char *) argv->buffer);
596	jermar	770	if (!symaddr)
		771	printf("Symbol %s not found.\n", argv->buffer);
1780	jermar	772	else if (symaddr == (uintptr_t) -1) {
2114	decky	773	symtab_print_search((char *) argv->buffer);
596	jermar	774	printf("Duplicate symbol, be more specific.\n");
		775	} else {
		776	symbol = get_symtab_entry(symaddr);
3065	decky	777	printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
		778	arg1, arg2, arg3, symaddr, symbol);
1666	palkovsky	779	#ifdef ia64
		780	fptr.f = symaddr;
1780	jermar	781	fptr.gp = ((unative_t *)cmd_call2)[1];
		782	f = (unative_t (*)(unative_t,unative_t,unative_t,...)) &fptr;
1666	palkovsky	783	#else
1780	jermar	784	f = (unative_t (*)(unative_t,unative_t,unative_t,...)) symaddr;
1666	palkovsky	785	#endif
3065	decky	786	printf("Result: %#" PRIxn "\n", f(arg1, arg2, arg3));
596	jermar	787	}
		788
		789	return 1;
		790	}
		791
		792
		793	/** Print detailed description of 'describe' command. */
		794	void desc_help(void)
		795	{
		796	printf("Syntax: describe command_name\n");
		797	}
		798
		799	/** Halt the kernel.
		800	*
		801	* @param argv Argument vector (ignored).
		802	*
		803	* @return 0 on failure, 1 on success (never returns).
		804	*/
		805	int cmd_halt(cmd_arg_t *argv)
		806	{
		807	halt();
		808	return 1;
		809	}
		810
		811	/** Command for printing TLB contents.
		812	*
		813	* @param argv Not used.
		814	*
		815	* @return Always returns 1.
		816	*/
673	jermar	817	int cmd_tlb(cmd_arg_t *argv)
596	jermar	818	{
		819	tlb_print();
		820	return 1;
		821	}
603	palkovsky	822
2721	decky	823	/** Command for printing physical memory configuration.
		824	*
		825	* @param argv Not used.
		826	*
		827	* @return Always returns 1.
		828	*/
		829	int cmd_physmem(cmd_arg_t *argv)
		830	{
		831	physmem_print();
		832	return 1;
		833	}
		834
603	palkovsky	835	/** Write 4 byte value to address */
		836	int cmd_set4(cmd_arg_t *argv)
		837	{
2216	decky	838	uint32_t *addr;
1780	jermar	839	uint32_t arg1 = argv[1].intval;
603	palkovsky	840	bool pointer = false;
		841
		842	if (((char )argv->buffer)[0] == '') {
2114	decky	843	addr = (uint32_t ) get_symbol_addr((char ) argv->buffer + 1);
603	palkovsky	844	pointer = true;
2114	decky	845	} else if (((char *) argv->buffer)[0] >= '0' &&
603	palkovsky	846	((char *)argv->buffer)[0] <= '9')
1780	jermar	847	addr = (uint32_t )atoi((char )argv->buffer);
603	palkovsky	848	else
2114	decky	849	addr = (uint32_t )get_symbol_addr((char ) argv->buffer);
603	palkovsky	850
		851	if (!addr)
		852	printf("Symbol %s not found.\n", argv->buffer);
1780	jermar	853	else if (addr == (uint32_t *) -1) {
2114	decky	854	symtab_print_search((char *) argv->buffer);
603	palkovsky	855	printf("Duplicate symbol, be more specific.\n");
		856	} else {
		857	if (pointer)
1780	jermar	858	addr = (uint32_t )((unative_t *)addr);
3065	decky	859	printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
603	palkovsky	860	*addr = arg1;
		861
		862	}
		863
		864	return 1;
		865	}
668	bondari	866
759	palkovsky	867	/** Command for listings SLAB caches
		868	*
		869	* @param argv Ignores
		870	*
		871	* @return Always 1
		872	*/
		873	int cmd_slabs(cmd_arg_t * argv) {
		874	slab_print_list();
		875	return 1;
		876	}
		877
777	palkovsky	878
775	palkovsky	879	/** Command for listings Thread information
		880	*
		881	* @param argv Ignores
		882	*
		883	* @return Always 1
		884	*/
777	palkovsky	885	int cmd_threads(cmd_arg_t * argv) {
		886	thread_print_list();
		887	return 1;
		888	}
		889
1060	palkovsky	890	/** Command for listings Task information
		891	*
		892	* @param argv Ignores
		893	*
		894	* @return Always 1
		895	*/
		896	int cmd_tasks(cmd_arg_t * argv) {
		897	task_print_list();
		898	return 1;
		899	}
		900
777	palkovsky	901	/** Command for listings Thread information
		902	*
		903	* @param argv Ignores
		904	*
		905	* @return Always 1
		906	*/
775	palkovsky	907	int cmd_sched(cmd_arg_t * argv) {
		908	sched_print_list();
		909	return 1;
		910	}
		911
677	bondari	912	/** Command for listing memory zones
		913	*
		914	* @param argv Ignored
		915	*
		916	* return Always 1
		917	*/
668	bondari	918	int cmd_zones(cmd_arg_t * argv) {
676	bondari	919	zone_print_list();
668	bondari	920	return 1;
		921	}
673	jermar	922
677	bondari	923	/** Command for memory zone details
		924	*
		925	* @param argv Integer argument from cmdline expected
		926	*
		927	* return Always 1
		928	*/
668	bondari	929	int cmd_zone(cmd_arg_t * argv) {
676	bondari	930	zone_print_one(argv[0].intval);
668	bondari	931	return 1;
		932	}
		933
1573	palkovsky	934	/** Command for printing task ipc details
		935	*
		936	* @param argv Integer argument from cmdline expected
		937	*
		938	* return Always 1
		939	*/
3451	jermar	940	int cmd_ipc(cmd_arg_t * argv) {
1573	palkovsky	941	ipc_print_task(argv[0].intval);
		942	return 1;
		943	}
		944
		945
673	jermar	946	/** Command for listing processors.
		947	*
		948	* @param argv Ignored.
		949	*
		950	* return Always 1.
		951	*/
		952	int cmd_cpus(cmd_arg_t *argv)
		953	{
		954	cpu_list();
		955	return 1;
		956	}
		957
		958	/** Command for printing kernel version.
		959	*
		960	* @param argv Ignored.
		961	*
		962	* return Always 1.
		963	*/
		964	int cmd_version(cmd_arg_t *argv)
		965	{
		966	version_print();
		967	return 1;
		968	}
1474	palkovsky	969
		970	/** Command for returning console back to userspace.
		971	*
		972	* @param argv Ignored.
		973	*
		974	* return Always 1.
		975	*/
		976	int cmd_continue(cmd_arg_t *argv)
		977	{
1695	jermar	978	printf("The kernel will now relinquish the console.\n");
		979	printf("Use userspace controls to redraw the screen.\n");
1474	palkovsky	980	arch_release_console();
		981	return 1;
		982	}
1702	cejka	983
2020	decky	984	#ifdef CONFIG_TEST
2019	decky	985	/** Command for printing kernel tests list.
		986	*
		987	* @param argv Ignored.
		988	*
		989	* return Always 1.
		990	*/
		991	int cmd_tests(cmd_arg_t *argv)
		992	{
		993	test_t *test;
		994
		995	for (test = tests; test->name != NULL; test++)
2020	decky	996	printf("%s\t\t%s%s\n", test->name, test->desc, (test->safe ? "" : " (unsafe)"));
2019	decky	997
2020	decky	998	printf("*\t\tRun all safe tests\n");
2019	decky	999	return 1;
		1000	}
		1001
2042	decky	1002	static bool run_test(const test_t *test)
2027	decky	1003	{
2042	decky	1004	printf("%s\t\t%s\n", test->name, test->desc);
2030	decky	1005
		1006	/* Update and read thread accounting
		1007	for benchmarking */
		1008	ipl_t ipl = interrupts_disable();
2039	decky	1009	spinlock_lock(&TASK->lock);
		1010	uint64_t t0 = task_get_accounting(TASK);
		1011	spinlock_unlock(&TASK->lock);
2030	decky	1012	interrupts_restore(ipl);
		1013
		1014	/* Execute the test */
2050	decky	1015	char * ret = test->entry(false);
2030	decky	1016
		1017	/* Update and read thread accounting */
		1018	ipl = interrupts_disable();
2039	decky	1019	spinlock_lock(&TASK->lock);
		1020	uint64_t dt = task_get_accounting(TASK) - t0;
		1021	spinlock_unlock(&TASK->lock);
2030	decky	1022	interrupts_restore(ipl);
		1023
2050	decky	1024	uint64_t cycles;
		1025	char suffix;
		1026	order(dt, &cycles, &suffix);
		1027
3065	decky	1028	printf("Time: %" PRIu64 "%c cycles\n", cycles, suffix);
2027	decky	1029
		1030	if (ret == NULL) {
		1031	printf("Test passed\n");
2042	decky	1032	return true;
2027	decky	1033	}
		1034
		1035	printf("%s\n", ret);
2042	decky	1036	return false;
2027	decky	1037	}
		1038
2050	decky	1039	static bool run_bench(const test_t *test, const uint32_t cnt)
		1040	{
		1041	uint32_t i;
		1042	bool ret = true;
		1043	uint64_t cycles;
		1044	char suffix;
		1045
		1046	if (cnt < 1)
		1047	return true;
		1048
2114	decky	1049	uint64_t data = (uint64_t ) malloc(sizeof(uint64_t) * cnt, 0);
2050	decky	1050	if (data == NULL) {
		1051	printf("Error allocating memory for statistics\n");
		1052	return false;
		1053	}
		1054
		1055	for (i = 0; i < cnt; i++) {
3065	decky	1056	printf("%s (%u/%u) ... ", test->name, i + 1, cnt);
2050	decky	1057
		1058	/* Update and read thread accounting
		1059	for benchmarking */
		1060	ipl_t ipl = interrupts_disable();
		1061	spinlock_lock(&TASK->lock);
		1062	uint64_t t0 = task_get_accounting(TASK);
		1063	spinlock_unlock(&TASK->lock);
		1064	interrupts_restore(ipl);
		1065
		1066	/* Execute the test */
		1067	char * ret = test->entry(true);
		1068
		1069	/* Update and read thread accounting */
		1070	ipl = interrupts_disable();
		1071	spinlock_lock(&TASK->lock);
		1072	uint64_t dt = task_get_accounting(TASK) - t0;
		1073	spinlock_unlock(&TASK->lock);
		1074	interrupts_restore(ipl);
		1075
		1076	if (ret != NULL) {
		1077	printf("%s\n", ret);
		1078	ret = false;
		1079	break;
		1080	}
		1081
		1082	data[i] = dt;
		1083	order(dt, &cycles, &suffix);
3065	decky	1084	printf("OK (%" PRIu64 "%c cycles)\n", cycles, suffix);
2050	decky	1085	}
		1086
		1087	if (ret) {
		1088	printf("\n");
		1089
		1090	uint64_t sum = 0;
		1091
		1092	for (i = 0; i < cnt; i++) {
		1093	sum += data[i];
		1094	}
		1095
		1096	order(sum / (uint64_t) cnt, &cycles, &suffix);
3065	decky	1097	printf("Average\t\t%" PRIu64 "%c\n", cycles, suffix);
2050	decky	1098	}
		1099
		1100	free(data);
		1101
		1102	return ret;
		1103	}
		1104
2019	decky	1105	/** Command for returning kernel tests
		1106	*
		1107	* @param argv Argument vector.
		1108	*
		1109	* return Always 1.
		1110	*/
		1111	int cmd_test(cmd_arg_t *argv)
		1112	{
		1113	test_t *test;
		1114
2114	decky	1115	if (strcmp((char ) argv->buffer, "") == 0) {
2020	decky	1116	for (test = tests; test->name != NULL; test++) {
		1117	if (test->safe) {
2027	decky	1118	printf("\n");
		1119	if (!run_test(test))
		1120	break;
2020	decky	1121	}
2019	decky	1122	}
2020	decky	1123	} else {
		1124	bool fnd = false;
		1125
		1126	for (test = tests; test->name != NULL; test++) {
2114	decky	1127	if (strcmp(test->name, (char *) argv->buffer) == 0) {
2020	decky	1128	fnd = true;
2027	decky	1129	run_test(test);
2020	decky	1130	break;
		1131	}
		1132	}
		1133
		1134	if (!fnd)
2027	decky	1135	printf("Unknown test\n");
2019	decky	1136	}
		1137
		1138	return 1;
		1139	}
2050	decky	1140
		1141	/** Command for returning kernel tests as benchmarks
		1142	*
		1143	* @param argv Argument vector.
		1144	*
		1145	* return Always 1.
		1146	*/
		1147	int cmd_bench(cmd_arg_t *argv)
		1148	{
		1149	test_t *test;
		1150	uint32_t cnt = argv[1].intval;
		1151
		1152	bool fnd = false;
		1153
		1154	for (test = tests; test->name != NULL; test++) {
2114	decky	1155	if (strcmp(test->name, (char *) argv->buffer) == 0) {
2050	decky	1156	fnd = true;
2051	decky	1157
		1158	if (test->safe)
		1159	run_bench(test, cnt);
		1160	else
		1161	printf("Unsafe test\n");
		1162
2050	decky	1163	break;
		1164	}
		1165	}
		1166
		1167	if (!fnd)
		1168	printf("Unknown test\n");
		1169
		1170	return 1;
		1171	}
		1172
2020	decky	1173	#endif
2019	decky	1174
1888	jermar	1175	/** @}
1702	cejka	1176	*/

Subversion Repositories HelenOS

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