1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * kgdbts is a test suite for kgdb for the sole purpose of validating
   4 * that key pieces of the kgdb internals are working properly such as
   5 * HW/SW breakpoints, single stepping, and NMI.
   6 *
   7 * Created by: Jason Wessel <jason.wessel@windriver.com>
   8 *
   9 * Copyright (c) 2008 Wind River Systems, Inc.
  10 */
  11/* Information about the kgdb test suite.
  12 * -------------------------------------
  13 *
  14 * The kgdb test suite is designed as a KGDB I/O module which
  15 * simulates the communications that a debugger would have with kgdb.
  16 * The tests are broken up in to a line by line and referenced here as
  17 * a "get" which is kgdb requesting input and "put" which is kgdb
  18 * sending a response.
  19 *
  20 * The kgdb suite can be invoked from the kernel command line
  21 * arguments system or executed dynamically at run time.  The test
  22 * suite uses the variable "kgdbts" to obtain the information about
  23 * which tests to run and to configure the verbosity level.  The
  24 * following are the various characters you can use with the kgdbts=
  25 * line:
  26 *
  27 * When using the "kgdbts=" you only choose one of the following core
  28 * test types:
  29 * A = Run all the core tests silently
  30 * V1 = Run all the core tests with minimal output
  31 * V2 = Run all the core tests in debug mode
  32 *
  33 * You can also specify optional tests:
  34 * N## = Go to sleep with interrupts of for ## seconds
  35 *       to test the HW NMI watchdog
  36 * F## = Break at kernel_clone for ## iterations
  37 * S## = Break at sys_open for ## iterations
  38 * I## = Run the single step test ## iterations
  39 *
  40 * NOTE: that the kernel_clone and sys_open tests are mutually exclusive.
  41 *
  42 * To invoke the kgdb test suite from boot you use a kernel start
  43 * argument as follows:
  44 * 	kgdbts=V1 kgdbwait
  45 * Or if you wanted to perform the NMI test for 6 seconds and kernel_clone
  46 * test for 100 forks, you could use:
  47 * 	kgdbts=V1N6F100 kgdbwait
  48 *
  49 * The test suite can also be invoked at run time with:
  50 *	echo kgdbts=V1N6F100 > /sys/module/kgdbts/parameters/kgdbts
  51 * Or as another example:
  52 *	echo kgdbts=V2 > /sys/module/kgdbts/parameters/kgdbts
  53 *
  54 * When developing a new kgdb arch specific implementation or
  55 * using these tests for the purpose of regression testing,
  56 * several invocations are required.
  57 *
  58 * 1) Boot with the test suite enabled by using the kernel arguments
  59 *       "kgdbts=V1F100 kgdbwait"
  60 *    ## If kgdb arch specific implementation has NMI use
  61 *       "kgdbts=V1N6F100
  62 *
  63 * 2) After the system boot run the basic test.
  64 * echo kgdbts=V1 > /sys/module/kgdbts/parameters/kgdbts
  65 *
  66 * 3) Run the concurrency tests.  It is best to use n+1
  67 *    while loops where n is the number of cpus you have
  68 *    in your system.  The example below uses only two
  69 *    loops.
  70 *
  71 * ## This tests break points on sys_open
  72 * while [ 1 ] ; do find / > /dev/null 2>&1 ; done &
  73 * while [ 1 ] ; do find / > /dev/null 2>&1 ; done &
  74 * echo kgdbts=V1S10000 > /sys/module/kgdbts/parameters/kgdbts
  75 * fg # and hit control-c
  76 * fg # and hit control-c
  77 * ## This tests break points on kernel_clone
  78 * while [ 1 ] ; do date > /dev/null ; done &
  79 * while [ 1 ] ; do date > /dev/null ; done &
  80 * echo kgdbts=V1F1000 > /sys/module/kgdbts/parameters/kgdbts
  81 * fg # and hit control-c
  82 *
  83 */
  84
  85#include <linux/kernel.h>
  86#include <linux/kgdb.h>
  87#include <linux/ctype.h>
  88#include <linux/uaccess.h>
  89#include <linux/syscalls.h>
  90#include <linux/nmi.h>
  91#include <linux/delay.h>
  92#include <linux/kthread.h>
  93#include <linux/module.h>
  94#include <linux/sched/task.h>
  95#include <linux/kallsyms.h>
  96
  97#include <asm/sections.h>
 
  98
  99#define v1printk(a...) do {		\
 100	if (verbose)			\
 101		printk(KERN_INFO a);	\
 102} while (0)
 103#define v2printk(a...) do {		\
 104	if (verbose > 1) {		\
 105		printk(KERN_INFO a);	\
 106	}				\
 107	touch_nmi_watchdog();		\
 108} while (0)
 109#define eprintk(a...) do {		\
 110	printk(KERN_ERR a);		\
 111	WARN_ON(1);			\
 112} while (0)
 113#define MAX_CONFIG_LEN		40
 114
 115static struct kgdb_io kgdbts_io_ops;
 116static char get_buf[BUFMAX];
 117static int get_buf_cnt;
 118static char put_buf[BUFMAX];
 119static int put_buf_cnt;
 120static char scratch_buf[BUFMAX];
 121static int verbose;
 122static int repeat_test;
 123static int test_complete;
 124static int send_ack;
 125static int final_ack;
 126static int force_hwbrks;
 127static int hwbreaks_ok;
 128static int hw_break_val;
 129static int hw_break_val2;
 130static int cont_instead_of_sstep;
 131static unsigned long cont_thread_id;
 132static unsigned long sstep_thread_id;
 133#if defined(CONFIG_ARM) || defined(CONFIG_MIPS) || defined(CONFIG_SPARC)
 134static int arch_needs_sstep_emulation = 1;
 135#else
 136static int arch_needs_sstep_emulation;
 137#endif
 138static unsigned long cont_addr;
 139static unsigned long sstep_addr;
 140static int restart_from_top_after_write;
 141static int sstep_state;
 142
 143/* Storage for the registers, in GDB format. */
 144static unsigned long kgdbts_gdb_regs[(NUMREGBYTES +
 145					sizeof(unsigned long) - 1) /
 146					sizeof(unsigned long)];
 147static struct pt_regs kgdbts_regs;
 148
 149/* -1 = init not run yet, 0 = unconfigured, 1 = configured. */
 150static int configured		= -1;
 151
 152#ifdef CONFIG_KGDB_TESTS_BOOT_STRING
 153static char config[MAX_CONFIG_LEN] = CONFIG_KGDB_TESTS_BOOT_STRING;
 154#else
 155static char config[MAX_CONFIG_LEN];
 156#endif
 157static struct kparam_string kps = {
 158	.string			= config,
 159	.maxlen			= MAX_CONFIG_LEN,
 160};
 161
 162static void fill_get_buf(char *buf);
 163
 164struct test_struct {
 165	char *get;
 166	char *put;
 167	void (*get_handler)(char *);
 168	int (*put_handler)(char *, char *);
 169};
 170
 171struct test_state {
 172	char *name;
 173	struct test_struct *tst;
 174	int idx;
 175	int (*run_test) (int, int);
 176	int (*validate_put) (char *);
 177};
 178
 179static struct test_state ts;
 180
 181static int kgdbts_unreg_thread(void *ptr)
 182{
 183	/* Wait until the tests are complete and then ungresiter the I/O
 184	 * driver.
 185	 */
 186	while (!final_ack)
 187		msleep_interruptible(1500);
 188	/* Pause for any other threads to exit after final ack. */
 189	msleep_interruptible(1000);
 190	if (configured)
 191		kgdb_unregister_io_module(&kgdbts_io_ops);
 192	configured = 0;
 193
 194	return 0;
 195}
 196
 197/* This is noinline such that it can be used for a single location to
 198 * place a breakpoint
 199 */
 200static noinline void kgdbts_break_test(void)
 201{
 202	v2printk("kgdbts: breakpoint complete\n");
 203}
 204
 205/*
 206 * This is a cached wrapper for kallsyms_lookup_name().
 207 *
 208 * The cache is a big win for several tests. For example it more the doubles
 209 * the cycles per second during the sys_open test. This is not theoretic,
 210 * the performance improvement shows up at human scale, especially when
 211 * testing using emulators.
 212 *
 213 * Obviously neither re-entrant nor thread-safe but that is OK since it
 214 * can only be called from the debug trap (and therefore all other CPUs
 215 * are halted).
 216 */
 217static unsigned long lookup_addr(char *arg)
 218{
 219	static char cached_arg[KSYM_NAME_LEN];
 220	static unsigned long cached_addr;
 221
 222	if (strcmp(arg, cached_arg)) {
 223		strscpy(cached_arg, arg, KSYM_NAME_LEN);
 224		cached_addr = kallsyms_lookup_name(arg);
 225	}
 226
 227	return (unsigned long)dereference_function_descriptor(
 228			(void *)cached_addr);
 229}
 230
 231static void break_helper(char *bp_type, char *arg, unsigned long vaddr)
 232{
 233	unsigned long addr;
 234
 235	if (arg)
 236		addr = lookup_addr(arg);
 237	else
 238		addr = vaddr;
 239
 240	sprintf(scratch_buf, "%s,%lx,%i", bp_type, addr,
 241		BREAK_INSTR_SIZE);
 242	fill_get_buf(scratch_buf);
 243}
 244
 245static void sw_break(char *arg)
 246{
 247	break_helper(force_hwbrks ? "Z1" : "Z0", arg, 0);
 248}
 249
 250static void sw_rem_break(char *arg)
 251{
 252	break_helper(force_hwbrks ? "z1" : "z0", arg, 0);
 253}
 254
 255static void hw_break(char *arg)
 256{
 257	break_helper("Z1", arg, 0);
 258}
 259
 260static void hw_rem_break(char *arg)
 261{
 262	break_helper("z1", arg, 0);
 263}
 264
 265static void hw_write_break(char *arg)
 266{
 267	break_helper("Z2", arg, 0);
 268}
 269
 270static void hw_rem_write_break(char *arg)
 271{
 272	break_helper("z2", arg, 0);
 273}
 274
 275static void hw_access_break(char *arg)
 276{
 277	break_helper("Z4", arg, 0);
 278}
 279
 280static void hw_rem_access_break(char *arg)
 281{
 282	break_helper("z4", arg, 0);
 283}
 284
 285static void hw_break_val_access(void)
 286{
 287	hw_break_val2 = hw_break_val;
 288}
 289
 290static void hw_break_val_write(void)
 291{
 292	hw_break_val++;
 293}
 294
 295static int get_thread_id_continue(char *put_str, char *arg)
 296{
 297	char *ptr = &put_str[11];
 298
 299	if (put_str[1] != 'T' || put_str[2] != '0')
 300		return 1;
 301	kgdb_hex2long(&ptr, &cont_thread_id);
 302	return 0;
 303}
 304
 305static int check_and_rewind_pc(char *put_str, char *arg)
 306{
 307	unsigned long addr = lookup_addr(arg);
 308	unsigned long ip;
 309	int offset = 0;
 310
 311	kgdb_hex2mem(&put_str[1], (char *)kgdbts_gdb_regs,
 312		 NUMREGBYTES);
 313	gdb_regs_to_pt_regs(kgdbts_gdb_regs, &kgdbts_regs);
 314	ip = instruction_pointer(&kgdbts_regs);
 315	v2printk("Stopped at IP: %lx\n", ip);
 316#ifdef GDB_ADJUSTS_BREAK_OFFSET
 317	/* On some arches, a breakpoint stop requires it to be decremented */
 318	if (addr + BREAK_INSTR_SIZE == ip)
 319		offset = -BREAK_INSTR_SIZE;
 320#endif
 321
 322	if (arch_needs_sstep_emulation && sstep_addr &&
 323	    ip + offset == sstep_addr &&
 324	    ((!strcmp(arg, "do_sys_openat2") || !strcmp(arg, "kernel_clone")))) {
 325		/* This is special case for emulated single step */
 326		v2printk("Emul: rewind hit single step bp\n");
 327		restart_from_top_after_write = 1;
 328	} else if (strcmp(arg, "silent") && ip + offset != addr) {
 329		eprintk("kgdbts: BP mismatch %lx expected %lx\n",
 330			   ip + offset, addr);
 331		return 1;
 332	}
 333	/* Readjust the instruction pointer if needed */
 334	ip += offset;
 335	cont_addr = ip;
 336#ifdef GDB_ADJUSTS_BREAK_OFFSET
 337	instruction_pointer_set(&kgdbts_regs, ip);
 338#endif
 339	return 0;
 340}
 341
 342static int check_single_step(char *put_str, char *arg)
 343{
 344	unsigned long addr = lookup_addr(arg);
 345	static int matched_id;
 346
 347	/*
 348	 * From an arch indepent point of view the instruction pointer
 349	 * should be on a different instruction
 350	 */
 351	kgdb_hex2mem(&put_str[1], (char *)kgdbts_gdb_regs,
 352		 NUMREGBYTES);
 353	gdb_regs_to_pt_regs(kgdbts_gdb_regs, &kgdbts_regs);
 354	v2printk("Singlestep stopped at IP: %lx\n",
 355		   instruction_pointer(&kgdbts_regs));
 356
 357	if (sstep_thread_id != cont_thread_id) {
 358		/*
 359		 * Ensure we stopped in the same thread id as before, else the
 360		 * debugger should continue until the original thread that was
 361		 * single stepped is scheduled again, emulating gdb's behavior.
 362		 */
 363		v2printk("ThrID does not match: %lx\n", cont_thread_id);
 364		if (arch_needs_sstep_emulation) {
 365			if (matched_id &&
 366			    instruction_pointer(&kgdbts_regs) != addr)
 367				goto continue_test;
 368			matched_id++;
 369			ts.idx -= 2;
 370			sstep_state = 0;
 371			return 0;
 372		}
 373		cont_instead_of_sstep = 1;
 374		ts.idx -= 4;
 375		return 0;
 376	}
 377continue_test:
 378	matched_id = 0;
 379	if (instruction_pointer(&kgdbts_regs) == addr) {
 380		eprintk("kgdbts: SingleStep failed at %lx\n",
 381			   instruction_pointer(&kgdbts_regs));
 382		return 1;
 383	}
 384
 385	return 0;
 386}
 387
 388static void write_regs(char *arg)
 389{
 390	memset(scratch_buf, 0, sizeof(scratch_buf));
 391	scratch_buf[0] = 'G';
 392	pt_regs_to_gdb_regs(kgdbts_gdb_regs, &kgdbts_regs);
 393	kgdb_mem2hex((char *)kgdbts_gdb_regs, &scratch_buf[1], NUMREGBYTES);
 394	fill_get_buf(scratch_buf);
 395}
 396
 397static void skip_back_repeat_test(char *arg)
 398{
 399	int go_back = simple_strtol(arg, NULL, 10);
 400
 401	repeat_test--;
 402	if (repeat_test <= 0) {
 403		ts.idx++;
 404	} else {
 405		if (repeat_test % 100 == 0)
 406			v1printk("kgdbts:RUN ... %d remaining\n", repeat_test);
 407
 408		ts.idx -= go_back;
 409	}
 410	fill_get_buf(ts.tst[ts.idx].get);
 411}
 412
 413static int got_break(char *put_str, char *arg)
 414{
 415	test_complete = 1;
 416	if (!strncmp(put_str+1, arg, 2)) {
 417		if (!strncmp(arg, "T0", 2))
 418			test_complete = 2;
 419		return 0;
 420	}
 421	return 1;
 422}
 423
 424static void get_cont_catch(char *arg)
 425{
 426	/* Always send detach because the test is completed at this point */
 427	fill_get_buf("D");
 428}
 429
 430static int put_cont_catch(char *put_str, char *arg)
 431{
 432	/* This is at the end of the test and we catch any and all input */
 433	v2printk("kgdbts: cleanup task: %lx\n", sstep_thread_id);
 434	ts.idx--;
 435	return 0;
 436}
 437
 438static int emul_reset(char *put_str, char *arg)
 439{
 440	if (strncmp(put_str, "$OK", 3))
 441		return 1;
 442	if (restart_from_top_after_write) {
 443		restart_from_top_after_write = 0;
 444		ts.idx = -1;
 445	}
 446	return 0;
 447}
 448
 449static void emul_sstep_get(char *arg)
 450{
 451	if (!arch_needs_sstep_emulation) {
 452		if (cont_instead_of_sstep) {
 453			cont_instead_of_sstep = 0;
 454			fill_get_buf("c");
 455		} else {
 456			fill_get_buf(arg);
 457		}
 458		return;
 459	}
 460	switch (sstep_state) {
 461	case 0:
 462		v2printk("Emulate single step\n");
 463		/* Start by looking at the current PC */
 464		fill_get_buf("g");
 465		break;
 466	case 1:
 467		/* set breakpoint */
 468		break_helper("Z0", NULL, sstep_addr);
 469		break;
 470	case 2:
 471		/* Continue */
 472		fill_get_buf("c");
 473		break;
 474	case 3:
 475		/* Clear breakpoint */
 476		break_helper("z0", NULL, sstep_addr);
 477		break;
 478	default:
 479		eprintk("kgdbts: ERROR failed sstep get emulation\n");
 480	}
 481	sstep_state++;
 482}
 483
 484static int emul_sstep_put(char *put_str, char *arg)
 485{
 486	if (!arch_needs_sstep_emulation) {
 487		char *ptr = &put_str[11];
 488		if (put_str[1] != 'T' || put_str[2] != '0')
 489			return 1;
 490		kgdb_hex2long(&ptr, &sstep_thread_id);
 491		return 0;
 492	}
 493	switch (sstep_state) {
 494	case 1:
 495		/* validate the "g" packet to get the IP */
 496		kgdb_hex2mem(&put_str[1], (char *)kgdbts_gdb_regs,
 497			 NUMREGBYTES);
 498		gdb_regs_to_pt_regs(kgdbts_gdb_regs, &kgdbts_regs);
 499		v2printk("Stopped at IP: %lx\n",
 500			 instruction_pointer(&kgdbts_regs));
 501		/* Want to stop at IP + break instruction size by default */
 502		sstep_addr = cont_addr + BREAK_INSTR_SIZE;
 503		break;
 504	case 2:
 505		if (strncmp(put_str, "$OK", 3)) {
 506			eprintk("kgdbts: failed sstep break set\n");
 507			return 1;
 508		}
 509		break;
 510	case 3:
 511		if (strncmp(put_str, "$T0", 3)) {
 512			eprintk("kgdbts: failed continue sstep\n");
 513			return 1;
 514		} else {
 515			char *ptr = &put_str[11];
 516			kgdb_hex2long(&ptr, &sstep_thread_id);
 517		}
 518		break;
 519	case 4:
 520		if (strncmp(put_str, "$OK", 3)) {
 521			eprintk("kgdbts: failed sstep break unset\n");
 522			return 1;
 523		}
 524		/* Single step is complete so continue on! */
 525		sstep_state = 0;
 526		return 0;
 527	default:
 528		eprintk("kgdbts: ERROR failed sstep put emulation\n");
 529	}
 530
 531	/* Continue on the same test line until emulation is complete */
 532	ts.idx--;
 533	return 0;
 534}
 535
 536static int final_ack_set(char *put_str, char *arg)
 537{
 538	if (strncmp(put_str+1, arg, 2))
 539		return 1;
 540	final_ack = 1;
 541	return 0;
 542}
 543/*
 544 * Test to plant a breakpoint and detach, which should clear out the
 545 * breakpoint and restore the original instruction.
 546 */
 547static struct test_struct plant_and_detach_test[] = {
 548	{ "?", "S0*" }, /* Clear break points */
 549	{ "kgdbts_break_test", "OK", sw_break, }, /* set sw breakpoint */
 550	{ "D", "OK" }, /* Detach */
 551	{ "", "" },
 552};
 553
 554/*
 555 * Simple test to write in a software breakpoint, check for the
 556 * correct stop location and detach.
 557 */
 558static struct test_struct sw_breakpoint_test[] = {
 559	{ "?", "S0*" }, /* Clear break points */
 560	{ "kgdbts_break_test", "OK", sw_break, }, /* set sw breakpoint */
 561	{ "c", "T0*", }, /* Continue */
 562	{ "g", "kgdbts_break_test", NULL, check_and_rewind_pc },
 563	{ "write", "OK", write_regs },
 564	{ "kgdbts_break_test", "OK", sw_rem_break }, /*remove breakpoint */
 565	{ "D", "OK" }, /* Detach */
 566	{ "D", "OK", NULL,  got_break }, /* On success we made it here */
 567	{ "", "" },
 568};
 569
 570/*
 571 * Test a known bad memory read location to test the fault handler and
 572 * read bytes 1-8 at the bad address
 573 */
 574static struct test_struct bad_read_test[] = {
 575	{ "?", "S0*" }, /* Clear break points */
 576	{ "m0,1", "E*" }, /* read 1 byte at address 1 */
 577	{ "m0,2", "E*" }, /* read 1 byte at address 2 */
 578	{ "m0,3", "E*" }, /* read 1 byte at address 3 */
 579	{ "m0,4", "E*" }, /* read 1 byte at address 4 */
 580	{ "m0,5", "E*" }, /* read 1 byte at address 5 */
 581	{ "m0,6", "E*" }, /* read 1 byte at address 6 */
 582	{ "m0,7", "E*" }, /* read 1 byte at address 7 */
 583	{ "m0,8", "E*" }, /* read 1 byte at address 8 */
 584	{ "D", "OK" }, /* Detach which removes all breakpoints and continues */
 585	{ "", "" },
 586};
 587
 588/*
 589 * Test for hitting a breakpoint, remove it, single step, plant it
 590 * again and detach.
 591 */
 592static struct test_struct singlestep_break_test[] = {
 593	{ "?", "S0*" }, /* Clear break points */
 594	{ "kgdbts_break_test", "OK", sw_break, }, /* set sw breakpoint */
 595	{ "c", "T0*", NULL, get_thread_id_continue }, /* Continue */
 596	{ "kgdbts_break_test", "OK", sw_rem_break }, /*remove breakpoint */
 597	{ "g", "kgdbts_break_test", NULL, check_and_rewind_pc },
 598	{ "write", "OK", write_regs }, /* Write registers */
 599	{ "s", "T0*", emul_sstep_get, emul_sstep_put }, /* Single step */
 600	{ "g", "kgdbts_break_test", NULL, check_single_step },
 601	{ "kgdbts_break_test", "OK", sw_break, }, /* set sw breakpoint */
 602	{ "c", "T0*", }, /* Continue */
 603	{ "g", "kgdbts_break_test", NULL, check_and_rewind_pc },
 604	{ "write", "OK", write_regs }, /* Write registers */
 605	{ "D", "OK" }, /* Remove all breakpoints and continues */
 606	{ "", "" },
 607};
 608
 609/*
 610 * Test for hitting a breakpoint at kernel_clone for what ever the number
 611 * of iterations required by the variable repeat_test.
 612 */
 613static struct test_struct do_kernel_clone_test[] = {
 614	{ "?", "S0*" }, /* Clear break points */
 615	{ "kernel_clone", "OK", sw_break, }, /* set sw breakpoint */
 616	{ "c", "T0*", NULL, get_thread_id_continue }, /* Continue */
 617	{ "kernel_clone", "OK", sw_rem_break }, /*remove breakpoint */
 618	{ "g", "kernel_clone", NULL, check_and_rewind_pc }, /* check location */
 619	{ "write", "OK", write_regs, emul_reset }, /* Write registers */
 620	{ "s", "T0*", emul_sstep_get, emul_sstep_put }, /* Single step */
 621	{ "g", "kernel_clone", NULL, check_single_step },
 622	{ "kernel_clone", "OK", sw_break, }, /* set sw breakpoint */
 623	{ "7", "T0*", skip_back_repeat_test }, /* Loop based on repeat_test */
 624	{ "D", "OK", NULL, final_ack_set }, /* detach and unregister I/O */
 625	{ "", "", get_cont_catch, put_cont_catch },
 626};
 627
 628/* Test for hitting a breakpoint at sys_open for what ever the number
 629 * of iterations required by the variable repeat_test.
 630 */
 631static struct test_struct sys_open_test[] = {
 632	{ "?", "S0*" }, /* Clear break points */
 633	{ "do_sys_openat2", "OK", sw_break, }, /* set sw breakpoint */
 634	{ "c", "T0*", NULL, get_thread_id_continue }, /* Continue */
 635	{ "do_sys_openat2", "OK", sw_rem_break }, /*remove breakpoint */
 636	{ "g", "do_sys_openat2", NULL, check_and_rewind_pc }, /* check location */
 637	{ "write", "OK", write_regs, emul_reset }, /* Write registers */
 638	{ "s", "T0*", emul_sstep_get, emul_sstep_put }, /* Single step */
 639	{ "g", "do_sys_openat2", NULL, check_single_step },
 640	{ "do_sys_openat2", "OK", sw_break, }, /* set sw breakpoint */
 641	{ "7", "T0*", skip_back_repeat_test }, /* Loop based on repeat_test */
 642	{ "D", "OK", NULL, final_ack_set }, /* detach and unregister I/O */
 643	{ "", "", get_cont_catch, put_cont_catch },
 644};
 645
 646/*
 647 * Test for hitting a simple hw breakpoint
 648 */
 649static struct test_struct hw_breakpoint_test[] = {
 650	{ "?", "S0*" }, /* Clear break points */
 651	{ "kgdbts_break_test", "OK", hw_break, }, /* set hw breakpoint */
 652	{ "c", "T0*", }, /* Continue */
 653	{ "g", "kgdbts_break_test", NULL, check_and_rewind_pc },
 654	{ "write", "OK", write_regs },
 655	{ "kgdbts_break_test", "OK", hw_rem_break }, /*remove breakpoint */
 656	{ "D", "OK" }, /* Detach */
 657	{ "D", "OK", NULL,  got_break }, /* On success we made it here */
 658	{ "", "" },
 659};
 660
 661/*
 662 * Test for hitting a hw write breakpoint
 663 */
 664static struct test_struct hw_write_break_test[] = {
 665	{ "?", "S0*" }, /* Clear break points */
 666	{ "hw_break_val", "OK", hw_write_break, }, /* set hw breakpoint */
 667	{ "c", "T0*", NULL, got_break }, /* Continue */
 668	{ "g", "silent", NULL, check_and_rewind_pc },
 669	{ "write", "OK", write_regs },
 670	{ "hw_break_val", "OK", hw_rem_write_break }, /*remove breakpoint */
 671	{ "D", "OK" }, /* Detach */
 672	{ "D", "OK", NULL,  got_break }, /* On success we made it here */
 673	{ "", "" },
 674};
 675
 676/*
 677 * Test for hitting a hw access breakpoint
 678 */
 679static struct test_struct hw_access_break_test[] = {
 680	{ "?", "S0*" }, /* Clear break points */
 681	{ "hw_break_val", "OK", hw_access_break, }, /* set hw breakpoint */
 682	{ "c", "T0*", NULL, got_break }, /* Continue */
 683	{ "g", "silent", NULL, check_and_rewind_pc },
 684	{ "write", "OK", write_regs },
 685	{ "hw_break_val", "OK", hw_rem_access_break }, /*remove breakpoint */
 686	{ "D", "OK" }, /* Detach */
 687	{ "D", "OK", NULL,  got_break }, /* On success we made it here */
 688	{ "", "" },
 689};
 690
 691/*
 692 * Test for hitting a hw access breakpoint
 693 */
 694static struct test_struct nmi_sleep_test[] = {
 695	{ "?", "S0*" }, /* Clear break points */
 696	{ "c", "T0*", NULL, got_break }, /* Continue */
 697	{ "D", "OK" }, /* Detach */
 698	{ "D", "OK", NULL,  got_break }, /* On success we made it here */
 699	{ "", "" },
 700};
 701
 702static void fill_get_buf(char *buf)
 703{
 704	unsigned char checksum = 0;
 705	int count = 0;
 706	char ch;
 707
 708	strcpy(get_buf, "$");
 709	strcat(get_buf, buf);
 710	while ((ch = buf[count])) {
 711		checksum += ch;
 712		count++;
 713	}
 714	strcat(get_buf, "#");
 715	get_buf[count + 2] = hex_asc_hi(checksum);
 716	get_buf[count + 3] = hex_asc_lo(checksum);
 717	get_buf[count + 4] = '\0';
 718	v2printk("get%i: %s\n", ts.idx, get_buf);
 719}
 720
 721static int validate_simple_test(char *put_str)
 722{
 723	char *chk_str;
 724
 725	if (ts.tst[ts.idx].put_handler)
 726		return ts.tst[ts.idx].put_handler(put_str,
 727			ts.tst[ts.idx].put);
 728
 729	chk_str = ts.tst[ts.idx].put;
 730	if (*put_str == '$')
 731		put_str++;
 732
 733	while (*chk_str != '\0' && *put_str != '\0') {
 734		/* If someone does a * to match the rest of the string, allow
 735		 * it, or stop if the received string is complete.
 736		 */
 737		if (*put_str == '#' || *chk_str == '*')
 738			return 0;
 739		if (*put_str != *chk_str)
 740			return 1;
 741
 742		chk_str++;
 743		put_str++;
 744	}
 745	if (*chk_str == '\0' && (*put_str == '\0' || *put_str == '#'))
 746		return 0;
 747
 748	return 1;
 749}
 750
 751static int run_simple_test(int is_get_char, int chr)
 752{
 753	int ret = 0;
 754	if (is_get_char) {
 755		/* Send an ACK on the get if a prior put completed and set the
 756		 * send ack variable
 757		 */
 758		if (send_ack) {
 759			send_ack = 0;
 760			return '+';
 761		}
 762		/* On the first get char, fill the transmit buffer and then
 763		 * take from the get_string.
 764		 */
 765		if (get_buf_cnt == 0) {
 766			if (ts.tst[ts.idx].get_handler)
 767				ts.tst[ts.idx].get_handler(ts.tst[ts.idx].get);
 768			else
 769				fill_get_buf(ts.tst[ts.idx].get);
 770		}
 771
 772		if (get_buf[get_buf_cnt] == '\0') {
 773			eprintk("kgdbts: ERROR GET: EOB on '%s' at %i\n",
 774			   ts.name, ts.idx);
 775			get_buf_cnt = 0;
 776			fill_get_buf("D");
 777		}
 778		ret = get_buf[get_buf_cnt];
 779		get_buf_cnt++;
 780		return ret;
 781	}
 782
 783	/* This callback is a put char which is when kgdb sends data to
 784	 * this I/O module.
 785	 */
 786	if (ts.tst[ts.idx].get[0] == '\0' && ts.tst[ts.idx].put[0] == '\0' &&
 787	    !ts.tst[ts.idx].get_handler) {
 788		eprintk("kgdbts: ERROR: beyond end of test on"
 789			   " '%s' line %i\n", ts.name, ts.idx);
 790		return 0;
 791	}
 792
 793	if (put_buf_cnt >= BUFMAX) {
 794		eprintk("kgdbts: ERROR: put buffer overflow on"
 795			   " '%s' line %i\n", ts.name, ts.idx);
 796		put_buf_cnt = 0;
 797		return 0;
 798	}
 799	/* Ignore everything until the first valid packet start '$' */
 800	if (put_buf_cnt == 0 && chr != '$')
 801		return 0;
 802
 803	put_buf[put_buf_cnt] = chr;
 804	put_buf_cnt++;
 805
 806	/* End of packet == #XX so look for the '#' */
 807	if (put_buf_cnt > 3 && put_buf[put_buf_cnt - 3] == '#') {
 808		if (put_buf_cnt >= BUFMAX) {
 809			eprintk("kgdbts: ERROR: put buffer overflow on"
 810				" '%s' line %i\n", ts.name, ts.idx);
 811			put_buf_cnt = 0;
 812			return 0;
 813		}
 814		put_buf[put_buf_cnt] = '\0';
 815		v2printk("put%i: %s\n", ts.idx, put_buf);
 816		/* Trigger check here */
 817		if (ts.validate_put && ts.validate_put(put_buf)) {
 818			eprintk("kgdbts: ERROR PUT: end of test "
 819			   "buffer on '%s' line %i expected %s got %s\n",
 820			   ts.name, ts.idx, ts.tst[ts.idx].put, put_buf);
 821		}
 822		ts.idx++;
 823		put_buf_cnt = 0;
 824		get_buf_cnt = 0;
 825		send_ack = 1;
 826	}
 827	return 0;
 828}
 829
 830static void init_simple_test(void)
 831{
 832	memset(&ts, 0, sizeof(ts));
 833	ts.run_test = run_simple_test;
 834	ts.validate_put = validate_simple_test;
 835}
 836
 837static void run_plant_and_detach_test(int is_early)
 838{
 839	char before[BREAK_INSTR_SIZE];
 840	char after[BREAK_INSTR_SIZE];
 841
 842	copy_from_kernel_nofault(before, (char *)kgdbts_break_test,
 843	  BREAK_INSTR_SIZE);
 844	init_simple_test();
 845	ts.tst = plant_and_detach_test;
 846	ts.name = "plant_and_detach_test";
 847	/* Activate test with initial breakpoint */
 848	if (!is_early)
 849		kgdb_breakpoint();
 850	copy_from_kernel_nofault(after, (char *)kgdbts_break_test,
 851			BREAK_INSTR_SIZE);
 852	if (memcmp(before, after, BREAK_INSTR_SIZE)) {
 853		printk(KERN_CRIT "kgdbts: ERROR kgdb corrupted memory\n");
 854		panic("kgdb memory corruption");
 855	}
 856
 857	/* complete the detach test */
 858	if (!is_early)
 859		kgdbts_break_test();
 860}
 861
 862static void run_breakpoint_test(int is_hw_breakpoint)
 863{
 864	test_complete = 0;
 865	init_simple_test();
 866	if (is_hw_breakpoint) {
 867		ts.tst = hw_breakpoint_test;
 868		ts.name = "hw_breakpoint_test";
 869	} else {
 870		ts.tst = sw_breakpoint_test;
 871		ts.name = "sw_breakpoint_test";
 872	}
 873	/* Activate test with initial breakpoint */
 874	kgdb_breakpoint();
 875	/* run code with the break point in it */
 876	kgdbts_break_test();
 877	kgdb_breakpoint();
 878
 879	if (test_complete)
 880		return;
 881
 882	eprintk("kgdbts: ERROR %s test failed\n", ts.name);
 883	if (is_hw_breakpoint)
 884		hwbreaks_ok = 0;
 885}
 886
 887static void run_hw_break_test(int is_write_test)
 888{
 889	test_complete = 0;
 890	init_simple_test();
 891	if (is_write_test) {
 892		ts.tst = hw_write_break_test;
 893		ts.name = "hw_write_break_test";
 894	} else {
 895		ts.tst = hw_access_break_test;
 896		ts.name = "hw_access_break_test";
 897	}
 898	/* Activate test with initial breakpoint */
 899	kgdb_breakpoint();
 900	hw_break_val_access();
 901	if (is_write_test) {
 902		if (test_complete == 2) {
 903			eprintk("kgdbts: ERROR %s broke on access\n",
 904				ts.name);
 905			hwbreaks_ok = 0;
 906		}
 907		hw_break_val_write();
 908	}
 909	kgdb_breakpoint();
 910
 911	if (test_complete == 1)
 912		return;
 913
 914	eprintk("kgdbts: ERROR %s test failed\n", ts.name);
 915	hwbreaks_ok = 0;
 916}
 917
 918static void run_nmi_sleep_test(int nmi_sleep)
 919{
 920	unsigned long flags;
 921
 922	init_simple_test();
 923	ts.tst = nmi_sleep_test;
 924	ts.name = "nmi_sleep_test";
 925	/* Activate test with initial breakpoint */
 926	kgdb_breakpoint();
 927	local_irq_save(flags);
 928	mdelay(nmi_sleep*1000);
 929	touch_nmi_watchdog();
 930	local_irq_restore(flags);
 931	if (test_complete != 2)
 932		eprintk("kgdbts: ERROR nmi_test did not hit nmi\n");
 933	kgdb_breakpoint();
 934	if (test_complete == 1)
 935		return;
 936
 937	eprintk("kgdbts: ERROR %s test failed\n", ts.name);
 938}
 939
 940static void run_bad_read_test(void)
 941{
 942	init_simple_test();
 943	ts.tst = bad_read_test;
 944	ts.name = "bad_read_test";
 945	/* Activate test with initial breakpoint */
 946	kgdb_breakpoint();
 947}
 948
 949static void run_kernel_clone_test(void)
 950{
 951	init_simple_test();
 952	ts.tst = do_kernel_clone_test;
 953	ts.name = "do_kernel_clone_test";
 954	/* Activate test with initial breakpoint */
 955	kgdb_breakpoint();
 956}
 957
 958static void run_sys_open_test(void)
 959{
 960	init_simple_test();
 961	ts.tst = sys_open_test;
 962	ts.name = "sys_open_test";
 963	/* Activate test with initial breakpoint */
 964	kgdb_breakpoint();
 965}
 966
 967static void run_singlestep_break_test(void)
 968{
 969	init_simple_test();
 970	ts.tst = singlestep_break_test;
 971	ts.name = "singlestep_breakpoint_test";
 972	/* Activate test with initial breakpoint */
 973	kgdb_breakpoint();
 974	kgdbts_break_test();
 975	kgdbts_break_test();
 976}
 977
 978static void kgdbts_run_tests(void)
 979{
 980	char *ptr;
 981	int clone_test = 0;
 982	int do_sys_open_test = 0;
 983	int sstep_test = 1000;
 984	int nmi_sleep = 0;
 985	int i;
 986
 987	verbose = 0;
 988	if (strstr(config, "V1"))
 989		verbose = 1;
 990	if (strstr(config, "V2"))
 991		verbose = 2;
 992
 993	ptr = strchr(config, 'F');
 994	if (ptr)
 995		clone_test = simple_strtol(ptr + 1, NULL, 10);
 996	ptr = strchr(config, 'S');
 997	if (ptr)
 998		do_sys_open_test = simple_strtol(ptr + 1, NULL, 10);
 999	ptr = strchr(config, 'N');
1000	if (ptr)
1001		nmi_sleep = simple_strtol(ptr+1, NULL, 10);
1002	ptr = strchr(config, 'I');
1003	if (ptr)
1004		sstep_test = simple_strtol(ptr+1, NULL, 10);
1005
1006	/* All HW break point tests */
1007	if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT) {
1008		hwbreaks_ok = 1;
1009		v1printk("kgdbts:RUN hw breakpoint test\n");
1010		run_breakpoint_test(1);
1011		v1printk("kgdbts:RUN hw write breakpoint test\n");
1012		run_hw_break_test(1);
1013		v1printk("kgdbts:RUN access write breakpoint test\n");
1014		run_hw_break_test(0);
1015	}
1016
1017	/* required internal KGDB tests */
1018	v1printk("kgdbts:RUN plant and detach test\n");
1019	run_plant_and_detach_test(0);
1020	v1printk("kgdbts:RUN sw breakpoint test\n");
1021	run_breakpoint_test(0);
1022	v1printk("kgdbts:RUN bad memory access test\n");
1023	run_bad_read_test();
1024	v1printk("kgdbts:RUN singlestep test %i iterations\n", sstep_test);
1025	for (i = 0; i < sstep_test; i++) {
1026		run_singlestep_break_test();
1027		if (i % 100 == 0)
1028			v1printk("kgdbts:RUN singlestep [%i/%i]\n",
1029				 i, sstep_test);
1030	}
1031
1032	/* ===Optional tests=== */
1033
1034	if (nmi_sleep) {
1035		v1printk("kgdbts:RUN NMI sleep %i seconds test\n", nmi_sleep);
1036		run_nmi_sleep_test(nmi_sleep);
1037	}
1038
1039	/* If the kernel_clone test is run it will be the last test that is
1040	 * executed because a kernel thread will be spawned at the very
1041	 * end to unregister the debug hooks.
1042	 */
1043	if (clone_test) {
1044		repeat_test = clone_test;
1045		printk(KERN_INFO "kgdbts:RUN kernel_clone for %i breakpoints\n",
1046			repeat_test);
1047		kthread_run(kgdbts_unreg_thread, NULL, "kgdbts_unreg");
1048		run_kernel_clone_test();
1049		return;
1050	}
1051
1052	/* If the sys_open test is run it will be the last test that is
1053	 * executed because a kernel thread will be spawned at the very
1054	 * end to unregister the debug hooks.
1055	 */
1056	if (do_sys_open_test) {
1057		repeat_test = do_sys_open_test;
1058		printk(KERN_INFO "kgdbts:RUN sys_open for %i breakpoints\n",
1059			repeat_test);
1060		kthread_run(kgdbts_unreg_thread, NULL, "kgdbts_unreg");
1061		run_sys_open_test();
1062		return;
1063	}
1064	/* Shutdown and unregister */
1065	kgdb_unregister_io_module(&kgdbts_io_ops);
1066	configured = 0;
1067}
1068
1069static int kgdbts_option_setup(char *opt)
1070{
1071	if (strlen(opt) >= MAX_CONFIG_LEN) {
1072		printk(KERN_ERR "kgdbts: config string too long\n");
1073		return 1;
1074	}
1075	strcpy(config, opt);
1076	return 1;
1077}
1078
1079__setup("kgdbts=", kgdbts_option_setup);
1080
1081static int configure_kgdbts(void)
1082{
1083	int err = 0;
1084
1085	if (!strlen(config) || isspace(config[0]))
1086		goto noconfig;
1087
1088	final_ack = 0;
1089	run_plant_and_detach_test(1);
1090
1091	err = kgdb_register_io_module(&kgdbts_io_ops);
1092	if (err) {
1093		configured = 0;
1094		return err;
1095	}
1096	configured = 1;
1097	kgdbts_run_tests();
1098
1099	return err;
1100
1101noconfig:
1102	config[0] = 0;
1103	configured = 0;
1104
1105	return err;
1106}
1107
1108static int __init init_kgdbts(void)
1109{
1110	/* Already configured? */
1111	if (configured == 1)
1112		return 0;
1113
1114	return configure_kgdbts();
1115}
1116device_initcall(init_kgdbts);
1117
1118static int kgdbts_get_char(void)
1119{
1120	int val = 0;
1121
1122	if (ts.run_test)
1123		val = ts.run_test(1, 0);
1124
1125	return val;
1126}
1127
1128static void kgdbts_put_char(u8 chr)
1129{
1130	if (ts.run_test)
1131		ts.run_test(0, chr);
1132}
1133
1134static int param_set_kgdbts_var(const char *kmessage,
1135				const struct kernel_param *kp)
1136{
1137	size_t len = strlen(kmessage);
1138
1139	if (len >= MAX_CONFIG_LEN) {
1140		printk(KERN_ERR "kgdbts: config string too long\n");
1141		return -ENOSPC;
1142	}
1143
1144	/* Only copy in the string if the init function has not run yet */
1145	if (configured < 0) {
1146		strcpy(config, kmessage);
1147		return 0;
1148	}
1149
1150	if (configured == 1) {
1151		printk(KERN_ERR "kgdbts: ERROR: Already configured and running.\n");
1152		return -EBUSY;
1153	}
1154
1155	strcpy(config, kmessage);
1156	/* Chop out \n char as a result of echo */
1157	if (len && config[len - 1] == '\n')
1158		config[len - 1] = '\0';
1159
1160	/* Go and configure with the new params. */
1161	return configure_kgdbts();
1162}
1163
1164static void kgdbts_pre_exp_handler(void)
1165{
1166	/* Increment the module count when the debugger is active */
1167	if (!kgdb_connected)
1168		try_module_get(THIS_MODULE);
1169}
1170
1171static void kgdbts_post_exp_handler(void)
1172{
1173	/* decrement the module count when the debugger detaches */
1174	if (!kgdb_connected)
1175		module_put(THIS_MODULE);
1176}
1177
1178static struct kgdb_io kgdbts_io_ops = {
1179	.name			= "kgdbts",
1180	.read_char		= kgdbts_get_char,
1181	.write_char		= kgdbts_put_char,
1182	.pre_exception		= kgdbts_pre_exp_handler,
1183	.post_exception		= kgdbts_post_exp_handler,
1184};
1185
1186/*
1187 * not really modular, but the easiest way to keep compat with existing
1188 * bootargs behaviour is to continue using module_param here.
1189 */
1190module_param_call(kgdbts, param_set_kgdbts_var, param_get_string, &kps, 0644);
1191MODULE_PARM_DESC(kgdbts, "<A|V1|V2>[F#|S#][N#]");