linux/drivers/misc/kgdbts.c
<<
>>
Prefs
   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
  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, "kernel_clone"))
 213                addr = (unsigned long)kernel_clone;
 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, "kernel_clone")))) {
 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 kernel_clone for what ever the number
 600 * of iterations required by the variable repeat_test.
 601 */
 602static struct test_struct do_kernel_clone_test[] = {
 603        { "?", "S0*" }, /* Clear break points */
 604        { "kernel_clone", "OK", sw_break, }, /* set sw breakpoint */
 605        { "c", "T0*", NULL, get_thread_id_continue }, /* Continue */
 606        { "kernel_clone", "OK", sw_rem_break }, /*remove breakpoint */
 607        { "g", "kernel_clone", 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", "kernel_clone", NULL, check_single_step },
 611        { "kernel_clone", "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        copy_from_kernel_nofault(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        copy_from_kernel_nofault(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_kernel_clone_test(void)
 939{
 940        init_simple_test();
 941        ts.tst = do_kernel_clone_test;
 942        ts.name = "do_kernel_clone_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 clone_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                clone_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 kernel_clone 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 (clone_test) {
1033                repeat_test = clone_test;
1034                printk(KERN_INFO "kgdbts:RUN kernel_clone for %i breakpoints\n",
1035                        repeat_test);
1036                kthread_run(kgdbts_unreg_thread, NULL, "kgdbts_unreg");
1037                run_kernel_clone_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#]");
1181