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