PageRenderTime 63ms CodeModel.GetById 11ms app.highlight 44ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/misc/kgdbts.c

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