linux/kernel/debug/debug_core.c
<<
>>
Prefs
   1/*
   2 * Kernel Debug Core
   3 *
   4 * Maintainer: Jason Wessel <jason.wessel@windriver.com>
   5 *
   6 * Copyright (C) 2000-2001 VERITAS Software Corporation.
   7 * Copyright (C) 2002-2004 Timesys Corporation
   8 * Copyright (C) 2003-2004 Amit S. Kale <amitkale@linsyssoft.com>
   9 * Copyright (C) 2004 Pavel Machek <pavel@ucw.cz>
  10 * Copyright (C) 2004-2006 Tom Rini <trini@kernel.crashing.org>
  11 * Copyright (C) 2004-2006 LinSysSoft Technologies Pvt. Ltd.
  12 * Copyright (C) 2005-2009 Wind River Systems, Inc.
  13 * Copyright (C) 2007 MontaVista Software, Inc.
  14 * Copyright (C) 2008 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
  15 *
  16 * Contributors at various stages not listed above:
  17 *  Jason Wessel ( jason.wessel@windriver.com )
  18 *  George Anzinger <george@mvista.com>
  19 *  Anurekh Saxena (anurekh.saxena@timesys.com)
  20 *  Lake Stevens Instrument Division (Glenn Engel)
  21 *  Jim Kingdon, Cygnus Support.
  22 *
  23 * Original KGDB stub: David Grothe <dave@gcom.com>,
  24 * Tigran Aivazian <tigran@sco.com>
  25 *
  26 * This file is licensed under the terms of the GNU General Public License
  27 * version 2. This program is licensed "as is" without any warranty of any
  28 * kind, whether express or implied.
  29 */
  30#include <linux/pid_namespace.h>
  31#include <linux/clocksource.h>
  32#include <linux/interrupt.h>
  33#include <linux/spinlock.h>
  34#include <linux/console.h>
  35#include <linux/threads.h>
  36#include <linux/uaccess.h>
  37#include <linux/kernel.h>
  38#include <linux/module.h>
  39#include <linux/ptrace.h>
  40#include <linux/string.h>
  41#include <linux/delay.h>
  42#include <linux/sched.h>
  43#include <linux/sysrq.h>
  44#include <linux/reboot.h>
  45#include <linux/init.h>
  46#include <linux/kgdb.h>
  47#include <linux/kdb.h>
  48#include <linux/pid.h>
  49#include <linux/smp.h>
  50#include <linux/mm.h>
  51#include <linux/rcupdate.h>
  52
  53#include <asm/cacheflush.h>
  54#include <asm/byteorder.h>
  55#include <linux/atomic.h>
  56
  57#include "debug_core.h"
  58
  59static int kgdb_break_asap;
  60
  61struct debuggerinfo_struct kgdb_info[NR_CPUS];
  62
  63/**
  64 * kgdb_connected - Is a host GDB connected to us?
  65 */
  66int                             kgdb_connected;
  67EXPORT_SYMBOL_GPL(kgdb_connected);
  68
  69/* All the KGDB handlers are installed */
  70int                     kgdb_io_module_registered;
  71
  72/* Guard for recursive entry */
  73static int                      exception_level;
  74
  75struct kgdb_io          *dbg_io_ops;
  76static DEFINE_SPINLOCK(kgdb_registration_lock);
  77
  78/* Action for the reboot notifiter, a global allow kdb to change it */
  79static int kgdbreboot;
  80/* kgdb console driver is loaded */
  81static int kgdb_con_registered;
  82/* determine if kgdb console output should be used */
  83static int kgdb_use_con;
  84/* Flag for alternate operations for early debugging */
  85bool dbg_is_early = true;
  86/* Next cpu to become the master debug core */
  87int dbg_switch_cpu;
  88
  89/* Use kdb or gdbserver mode */
  90int dbg_kdb_mode = 1;
  91
  92static int __init opt_kgdb_con(char *str)
  93{
  94        kgdb_use_con = 1;
  95        return 0;
  96}
  97
  98early_param("kgdbcon", opt_kgdb_con);
  99
 100module_param(kgdb_use_con, int, 0644);
 101module_param(kgdbreboot, int, 0644);
 102
 103/*
 104 * Holds information about breakpoints in a kernel. These breakpoints are
 105 * added and removed by gdb.
 106 */
 107static struct kgdb_bkpt         kgdb_break[KGDB_MAX_BREAKPOINTS] = {
 108        [0 ... KGDB_MAX_BREAKPOINTS-1] = { .state = BP_UNDEFINED }
 109};
 110
 111/*
 112 * The CPU# of the active CPU, or -1 if none:
 113 */
 114atomic_t                        kgdb_active = ATOMIC_INIT(-1);
 115EXPORT_SYMBOL_GPL(kgdb_active);
 116static DEFINE_RAW_SPINLOCK(dbg_master_lock);
 117static DEFINE_RAW_SPINLOCK(dbg_slave_lock);
 118
 119/*
 120 * We use NR_CPUs not PERCPU, in case kgdb is used to debug early
 121 * bootup code (which might not have percpu set up yet):
 122 */
 123static atomic_t                 masters_in_kgdb;
 124static atomic_t                 slaves_in_kgdb;
 125static atomic_t                 kgdb_break_tasklet_var;
 126atomic_t                        kgdb_setting_breakpoint;
 127
 128struct task_struct              *kgdb_usethread;
 129struct task_struct              *kgdb_contthread;
 130
 131int                             kgdb_single_step;
 132static pid_t                    kgdb_sstep_pid;
 133
 134/* to keep track of the CPU which is doing the single stepping*/
 135atomic_t                        kgdb_cpu_doing_single_step = ATOMIC_INIT(-1);
 136
 137/*
 138 * If you are debugging a problem where roundup (the collection of
 139 * all other CPUs) is a problem [this should be extremely rare],
 140 * then use the nokgdbroundup option to avoid roundup. In that case
 141 * the other CPUs might interfere with your debugging context, so
 142 * use this with care:
 143 */
 144static int kgdb_do_roundup = 1;
 145
 146static int __init opt_nokgdbroundup(char *str)
 147{
 148        kgdb_do_roundup = 0;
 149
 150        return 0;
 151}
 152
 153early_param("nokgdbroundup", opt_nokgdbroundup);
 154
 155/*
 156 * Finally, some KGDB code :-)
 157 */
 158
 159/*
 160 * Weak aliases for breakpoint management,
 161 * can be overriden by architectures when needed:
 162 */
 163int __weak kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
 164{
 165        int err;
 166
 167        err = probe_kernel_read(bpt->saved_instr, (char *)bpt->bpt_addr,
 168                                BREAK_INSTR_SIZE);
 169        if (err)
 170                return err;
 171        err = probe_kernel_write((char *)bpt->bpt_addr,
 172                                 arch_kgdb_ops.gdb_bpt_instr, BREAK_INSTR_SIZE);
 173        return err;
 174}
 175
 176int __weak kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
 177{
 178        return probe_kernel_write((char *)bpt->bpt_addr,
 179                                  (char *)bpt->saved_instr, BREAK_INSTR_SIZE);
 180}
 181
 182int __weak kgdb_validate_break_address(unsigned long addr)
 183{
 184        struct kgdb_bkpt tmp;
 185        int err;
 186        /* Validate setting the breakpoint and then removing it.  If the
 187         * remove fails, the kernel needs to emit a bad message because we
 188         * are deep trouble not being able to put things back the way we
 189         * found them.
 190         */
 191        tmp.bpt_addr = addr;
 192        err = kgdb_arch_set_breakpoint(&tmp);
 193        if (err)
 194                return err;
 195        err = kgdb_arch_remove_breakpoint(&tmp);
 196        if (err)
 197                printk(KERN_ERR "KGDB: Critical breakpoint error, kernel "
 198                   "memory destroyed at: %lx", addr);
 199        return err;
 200}
 201
 202unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs)
 203{
 204        return instruction_pointer(regs);
 205}
 206
 207int __weak kgdb_arch_init(void)
 208{
 209        return 0;
 210}
 211
 212int __weak kgdb_skipexception(int exception, struct pt_regs *regs)
 213{
 214        return 0;
 215}
 216
 217/*
 218 * Some architectures need cache flushes when we set/clear a
 219 * breakpoint:
 220 */
 221static void kgdb_flush_swbreak_addr(unsigned long addr)
 222{
 223        if (!CACHE_FLUSH_IS_SAFE)
 224                return;
 225
 226        if (current->mm && current->mm->mmap_cache) {
 227                flush_cache_range(current->mm->mmap_cache,
 228                                  addr, addr + BREAK_INSTR_SIZE);
 229        }
 230        /* Force flush instruction cache if it was outside the mm */
 231        flush_icache_range(addr, addr + BREAK_INSTR_SIZE);
 232}
 233
 234/*
 235 * SW breakpoint management:
 236 */
 237int dbg_activate_sw_breakpoints(void)
 238{
 239        int error;
 240        int ret = 0;
 241        int i;
 242
 243        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 244                if (kgdb_break[i].state != BP_SET)
 245                        continue;
 246
 247                error = kgdb_arch_set_breakpoint(&kgdb_break[i]);
 248                if (error) {
 249                        ret = error;
 250                        printk(KERN_INFO "KGDB: BP install failed: %lx",
 251                               kgdb_break[i].bpt_addr);
 252                        continue;
 253                }
 254
 255                kgdb_flush_swbreak_addr(kgdb_break[i].bpt_addr);
 256                kgdb_break[i].state = BP_ACTIVE;
 257        }
 258        return ret;
 259}
 260
 261int dbg_set_sw_break(unsigned long addr)
 262{
 263        int err = kgdb_validate_break_address(addr);
 264        int breakno = -1;
 265        int i;
 266
 267        if (err)
 268                return err;
 269
 270        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 271                if ((kgdb_break[i].state == BP_SET) &&
 272                                        (kgdb_break[i].bpt_addr == addr))
 273                        return -EEXIST;
 274        }
 275        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 276                if (kgdb_break[i].state == BP_REMOVED &&
 277                                        kgdb_break[i].bpt_addr == addr) {
 278                        breakno = i;
 279                        break;
 280                }
 281        }
 282
 283        if (breakno == -1) {
 284                for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 285                        if (kgdb_break[i].state == BP_UNDEFINED) {
 286                                breakno = i;
 287                                break;
 288                        }
 289                }
 290        }
 291
 292        if (breakno == -1)
 293                return -E2BIG;
 294
 295        kgdb_break[breakno].state = BP_SET;
 296        kgdb_break[breakno].type = BP_BREAKPOINT;
 297        kgdb_break[breakno].bpt_addr = addr;
 298
 299        return 0;
 300}
 301
 302int dbg_deactivate_sw_breakpoints(void)
 303{
 304        int error;
 305        int ret = 0;
 306        int i;
 307
 308        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 309                if (kgdb_break[i].state != BP_ACTIVE)
 310                        continue;
 311                error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
 312                if (error) {
 313                        printk(KERN_INFO "KGDB: BP remove failed: %lx\n",
 314                               kgdb_break[i].bpt_addr);
 315                        ret = error;
 316                }
 317
 318                kgdb_flush_swbreak_addr(kgdb_break[i].bpt_addr);
 319                kgdb_break[i].state = BP_SET;
 320        }
 321        return ret;
 322}
 323
 324int dbg_remove_sw_break(unsigned long addr)
 325{
 326        int i;
 327
 328        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 329                if ((kgdb_break[i].state == BP_SET) &&
 330                                (kgdb_break[i].bpt_addr == addr)) {
 331                        kgdb_break[i].state = BP_REMOVED;
 332                        return 0;
 333                }
 334        }
 335        return -ENOENT;
 336}
 337
 338int kgdb_isremovedbreak(unsigned long addr)
 339{
 340        int i;
 341
 342        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 343                if ((kgdb_break[i].state == BP_REMOVED) &&
 344                                        (kgdb_break[i].bpt_addr == addr))
 345                        return 1;
 346        }
 347        return 0;
 348}
 349
 350int dbg_remove_all_break(void)
 351{
 352        int error;
 353        int i;
 354
 355        /* Clear memory breakpoints. */
 356        for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 357                if (kgdb_break[i].state != BP_ACTIVE)
 358                        goto setundefined;
 359                error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
 360                if (error)
 361                        printk(KERN_ERR "KGDB: breakpoint remove failed: %lx\n",
 362                               kgdb_break[i].bpt_addr);
 363setundefined:
 364                kgdb_break[i].state = BP_UNDEFINED;
 365        }
 366
 367        /* Clear hardware breakpoints. */
 368        if (arch_kgdb_ops.remove_all_hw_break)
 369                arch_kgdb_ops.remove_all_hw_break();
 370
 371        return 0;
 372}
 373
 374/*
 375 * Return true if there is a valid kgdb I/O module.  Also if no
 376 * debugger is attached a message can be printed to the console about
 377 * waiting for the debugger to attach.
 378 *
 379 * The print_wait argument is only to be true when called from inside
 380 * the core kgdb_handle_exception, because it will wait for the
 381 * debugger to attach.
 382 */
 383static int kgdb_io_ready(int print_wait)
 384{
 385        if (!dbg_io_ops)
 386                return 0;
 387        if (kgdb_connected)
 388                return 1;
 389        if (atomic_read(&kgdb_setting_breakpoint))
 390                return 1;
 391        if (print_wait) {
 392#ifdef CONFIG_KGDB_KDB
 393                if (!dbg_kdb_mode)
 394                        printk(KERN_CRIT "KGDB: waiting... or $3#33 for KDB\n");
 395#else
 396                printk(KERN_CRIT "KGDB: Waiting for remote debugger\n");
 397#endif
 398        }
 399        return 1;
 400}
 401
 402static int kgdb_reenter_check(struct kgdb_state *ks)
 403{
 404        unsigned long addr;
 405
 406        if (atomic_read(&kgdb_active) != raw_smp_processor_id())
 407                return 0;
 408
 409        /* Panic on recursive debugger calls: */
 410        exception_level++;
 411        addr = kgdb_arch_pc(ks->ex_vector, ks->linux_regs);
 412        dbg_deactivate_sw_breakpoints();
 413
 414        /*
 415         * If the break point removed ok at the place exception
 416         * occurred, try to recover and print a warning to the end
 417         * user because the user planted a breakpoint in a place that
 418         * KGDB needs in order to function.
 419         */
 420        if (dbg_remove_sw_break(addr) == 0) {
 421                exception_level = 0;
 422                kgdb_skipexception(ks->ex_vector, ks->linux_regs);
 423                dbg_activate_sw_breakpoints();
 424                printk(KERN_CRIT "KGDB: re-enter error: breakpoint removed %lx\n",
 425                        addr);
 426                WARN_ON_ONCE(1);
 427
 428                return 1;
 429        }
 430        dbg_remove_all_break();
 431        kgdb_skipexception(ks->ex_vector, ks->linux_regs);
 432
 433        if (exception_level > 1) {
 434                dump_stack();
 435                panic("Recursive entry to debugger");
 436        }
 437
 438        printk(KERN_CRIT "KGDB: re-enter exception: ALL breakpoints killed\n");
 439#ifdef CONFIG_KGDB_KDB
 440        /* Allow kdb to debug itself one level */
 441        return 0;
 442#endif
 443        dump_stack();
 444        panic("Recursive entry to debugger");
 445
 446        return 1;
 447}
 448
 449static void dbg_touch_watchdogs(void)
 450{
 451        touch_softlockup_watchdog_sync();
 452        clocksource_touch_watchdog();
 453        rcu_cpu_stall_reset();
 454}
 455
 456static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs,
 457                int exception_state)
 458{
 459        unsigned long flags;
 460        int sstep_tries = 100;
 461        int error;
 462        int cpu;
 463        int trace_on = 0;
 464        int online_cpus = num_online_cpus();
 465
 466        kgdb_info[ks->cpu].enter_kgdb++;
 467        kgdb_info[ks->cpu].exception_state |= exception_state;
 468
 469        if (exception_state == DCPU_WANT_MASTER)
 470                atomic_inc(&masters_in_kgdb);
 471        else
 472                atomic_inc(&slaves_in_kgdb);
 473
 474        if (arch_kgdb_ops.disable_hw_break)
 475                arch_kgdb_ops.disable_hw_break(regs);
 476
 477acquirelock:
 478        /*
 479         * Interrupts will be restored by the 'trap return' code, except when
 480         * single stepping.
 481         */
 482        local_irq_save(flags);
 483
 484        cpu = ks->cpu;
 485        kgdb_info[cpu].debuggerinfo = regs;
 486        kgdb_info[cpu].task = current;
 487        kgdb_info[cpu].ret_state = 0;
 488        kgdb_info[cpu].irq_depth = hardirq_count() >> HARDIRQ_SHIFT;
 489
 490        /* Make sure the above info reaches the primary CPU */
 491        smp_mb();
 492
 493        if (exception_level == 1) {
 494                if (raw_spin_trylock(&dbg_master_lock))
 495                        atomic_xchg(&kgdb_active, cpu);
 496                goto cpu_master_loop;
 497        }
 498
 499        /*
 500         * CPU will loop if it is a slave or request to become a kgdb
 501         * master cpu and acquire the kgdb_active lock:
 502         */
 503        while (1) {
 504cpu_loop:
 505                if (kgdb_info[cpu].exception_state & DCPU_NEXT_MASTER) {
 506                        kgdb_info[cpu].exception_state &= ~DCPU_NEXT_MASTER;
 507                        goto cpu_master_loop;
 508                } else if (kgdb_info[cpu].exception_state & DCPU_WANT_MASTER) {
 509                        if (raw_spin_trylock(&dbg_master_lock)) {
 510                                atomic_xchg(&kgdb_active, cpu);
 511                                break;
 512                        }
 513                } else if (kgdb_info[cpu].exception_state & DCPU_IS_SLAVE) {
 514                        if (!raw_spin_is_locked(&dbg_slave_lock))
 515                                goto return_normal;
 516                } else {
 517return_normal:
 518                        /* Return to normal operation by executing any
 519                         * hw breakpoint fixup.
 520                         */
 521                        if (arch_kgdb_ops.correct_hw_break)
 522                                arch_kgdb_ops.correct_hw_break();
 523                        if (trace_on)
 524                                tracing_on();
 525                        kgdb_info[cpu].exception_state &=
 526                                ~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
 527                        kgdb_info[cpu].enter_kgdb--;
 528                        smp_mb__before_atomic_dec();
 529                        atomic_dec(&slaves_in_kgdb);
 530                        dbg_touch_watchdogs();
 531                        local_irq_restore(flags);
 532                        return 0;
 533                }
 534                cpu_relax();
 535        }
 536
 537        /*
 538         * For single stepping, try to only enter on the processor
 539         * that was single stepping.  To guard against a deadlock, the
 540         * kernel will only try for the value of sstep_tries before
 541         * giving up and continuing on.
 542         */
 543        if (atomic_read(&kgdb_cpu_doing_single_step) != -1 &&
 544            (kgdb_info[cpu].task &&
 545             kgdb_info[cpu].task->pid != kgdb_sstep_pid) && --sstep_tries) {
 546                atomic_set(&kgdb_active, -1);
 547                raw_spin_unlock(&dbg_master_lock);
 548                dbg_touch_watchdogs();
 549                local_irq_restore(flags);
 550
 551                goto acquirelock;
 552        }
 553
 554        if (!kgdb_io_ready(1)) {
 555                kgdb_info[cpu].ret_state = 1;
 556                goto kgdb_restore; /* No I/O connection, resume the system */
 557        }
 558
 559        /*
 560         * Don't enter if we have hit a removed breakpoint.
 561         */
 562        if (kgdb_skipexception(ks->ex_vector, ks->linux_regs))
 563                goto kgdb_restore;
 564
 565        /* Call the I/O driver's pre_exception routine */
 566        if (dbg_io_ops->pre_exception)
 567                dbg_io_ops->pre_exception();
 568
 569        /*
 570         * Get the passive CPU lock which will hold all the non-primary
 571         * CPU in a spin state while the debugger is active
 572         */
 573        if (!kgdb_single_step)
 574                raw_spin_lock(&dbg_slave_lock);
 575
 576#ifdef CONFIG_SMP
 577        /* Signal the other CPUs to enter kgdb_wait() */
 578        if ((!kgdb_single_step) && kgdb_do_roundup)
 579                kgdb_roundup_cpus(flags);
 580#endif
 581
 582        /*
 583         * Wait for the other CPUs to be notified and be waiting for us:
 584         */
 585        while (kgdb_do_roundup && (atomic_read(&masters_in_kgdb) +
 586                                atomic_read(&slaves_in_kgdb)) != online_cpus)
 587                cpu_relax();
 588
 589        /*
 590         * At this point the primary processor is completely
 591         * in the debugger and all secondary CPUs are quiescent
 592         */
 593        dbg_deactivate_sw_breakpoints();
 594        kgdb_single_step = 0;
 595        kgdb_contthread = current;
 596        exception_level = 0;
 597        trace_on = tracing_is_on();
 598        if (trace_on)
 599                tracing_off();
 600
 601        while (1) {
 602cpu_master_loop:
 603                if (dbg_kdb_mode) {
 604                        kgdb_connected = 1;
 605                        error = kdb_stub(ks);
 606                        if (error == -1)
 607                                continue;
 608                        kgdb_connected = 0;
 609                } else {
 610                        error = gdb_serial_stub(ks);
 611                }
 612
 613                if (error == DBG_PASS_EVENT) {
 614                        dbg_kdb_mode = !dbg_kdb_mode;
 615                } else if (error == DBG_SWITCH_CPU_EVENT) {
 616                        kgdb_info[dbg_switch_cpu].exception_state |=
 617                                DCPU_NEXT_MASTER;
 618                        goto cpu_loop;
 619                } else {
 620                        kgdb_info[cpu].ret_state = error;
 621                        break;
 622                }
 623        }
 624
 625        /* Call the I/O driver's post_exception routine */
 626        if (dbg_io_ops->post_exception)
 627                dbg_io_ops->post_exception();
 628
 629        if (!kgdb_single_step) {
 630                raw_spin_unlock(&dbg_slave_lock);
 631                /* Wait till all the CPUs have quit from the debugger. */
 632                while (kgdb_do_roundup && atomic_read(&slaves_in_kgdb))
 633                        cpu_relax();
 634        }
 635
 636kgdb_restore:
 637        if (atomic_read(&kgdb_cpu_doing_single_step) != -1) {
 638                int sstep_cpu = atomic_read(&kgdb_cpu_doing_single_step);
 639                if (kgdb_info[sstep_cpu].task)
 640                        kgdb_sstep_pid = kgdb_info[sstep_cpu].task->pid;
 641                else
 642                        kgdb_sstep_pid = 0;
 643        }
 644        if (arch_kgdb_ops.correct_hw_break)
 645                arch_kgdb_ops.correct_hw_break();
 646        if (trace_on)
 647                tracing_on();
 648
 649        kgdb_info[cpu].exception_state &=
 650                ~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
 651        kgdb_info[cpu].enter_kgdb--;
 652        smp_mb__before_atomic_dec();
 653        atomic_dec(&masters_in_kgdb);
 654        /* Free kgdb_active */
 655        atomic_set(&kgdb_active, -1);
 656        raw_spin_unlock(&dbg_master_lock);
 657        dbg_touch_watchdogs();
 658        local_irq_restore(flags);
 659
 660        return kgdb_info[cpu].ret_state;
 661}
 662
 663/*
 664 * kgdb_handle_exception() - main entry point from a kernel exception
 665 *
 666 * Locking hierarchy:
 667 *      interface locks, if any (begin_session)
 668 *      kgdb lock (kgdb_active)
 669 */
 670int
 671kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
 672{
 673        struct kgdb_state kgdb_var;
 674        struct kgdb_state *ks = &kgdb_var;
 675        int ret = 0;
 676
 677        if (arch_kgdb_ops.enable_nmi)
 678                arch_kgdb_ops.enable_nmi(0);
 679
 680        ks->cpu                 = raw_smp_processor_id();
 681        ks->ex_vector           = evector;
 682        ks->signo               = signo;
 683        ks->err_code            = ecode;
 684        ks->kgdb_usethreadid    = 0;
 685        ks->linux_regs          = regs;
 686
 687        if (kgdb_reenter_check(ks))
 688                goto out; /* Ouch, double exception ! */
 689        if (kgdb_info[ks->cpu].enter_kgdb != 0)
 690                goto out;
 691
 692        ret = kgdb_cpu_enter(ks, regs, DCPU_WANT_MASTER);
 693out:
 694        if (arch_kgdb_ops.enable_nmi)
 695                arch_kgdb_ops.enable_nmi(1);
 696        return ret;
 697}
 698
 699/*
 700 * GDB places a breakpoint at this function to know dynamically
 701 * loaded objects. It's not defined static so that only one instance with this
 702 * name exists in the kernel.
 703 */
 704
 705static int module_event(struct notifier_block *self, unsigned long val,
 706        void *data)
 707{
 708        return 0;
 709}
 710
 711static struct notifier_block dbg_module_load_nb = {
 712        .notifier_call  = module_event,
 713};
 714
 715int kgdb_nmicallback(int cpu, void *regs)
 716{
 717#ifdef CONFIG_SMP
 718        struct kgdb_state kgdb_var;
 719        struct kgdb_state *ks = &kgdb_var;
 720
 721        memset(ks, 0, sizeof(struct kgdb_state));
 722        ks->cpu                 = cpu;
 723        ks->linux_regs          = regs;
 724
 725        if (kgdb_info[ks->cpu].enter_kgdb == 0 &&
 726                        raw_spin_is_locked(&dbg_master_lock)) {
 727                kgdb_cpu_enter(ks, regs, DCPU_IS_SLAVE);
 728                return 0;
 729        }
 730#endif
 731        return 1;
 732}
 733
 734static void kgdb_console_write(struct console *co, const char *s,
 735   unsigned count)
 736{
 737        unsigned long flags;
 738
 739        /* If we're debugging, or KGDB has not connected, don't try
 740         * and print. */
 741        if (!kgdb_connected || atomic_read(&kgdb_active) != -1 || dbg_kdb_mode)
 742                return;
 743
 744        local_irq_save(flags);
 745        gdbstub_msg_write(s, count);
 746        local_irq_restore(flags);
 747}
 748
 749static struct console kgdbcons = {
 750        .name           = "kgdb",
 751        .write          = kgdb_console_write,
 752        .flags          = CON_PRINTBUFFER | CON_ENABLED,
 753        .index          = -1,
 754};
 755
 756#ifdef CONFIG_MAGIC_SYSRQ
 757static void sysrq_handle_dbg(int key)
 758{
 759        if (!dbg_io_ops) {
 760                printk(KERN_CRIT "ERROR: No KGDB I/O module available\n");
 761                return;
 762        }
 763        if (!kgdb_connected) {
 764#ifdef CONFIG_KGDB_KDB
 765                if (!dbg_kdb_mode)
 766                        printk(KERN_CRIT "KGDB or $3#33 for KDB\n");
 767#else
 768                printk(KERN_CRIT "Entering KGDB\n");
 769#endif
 770        }
 771
 772        kgdb_breakpoint();
 773}
 774
 775static struct sysrq_key_op sysrq_dbg_op = {
 776        .handler        = sysrq_handle_dbg,
 777        .help_msg       = "debug(G)",
 778        .action_msg     = "DEBUG",
 779};
 780#endif
 781
 782static int kgdb_panic_event(struct notifier_block *self,
 783                            unsigned long val,
 784                            void *data)
 785{
 786        if (dbg_kdb_mode)
 787                kdb_printf("PANIC: %s\n", (char *)data);
 788        kgdb_breakpoint();
 789        return NOTIFY_DONE;
 790}
 791
 792static struct notifier_block kgdb_panic_event_nb = {
 793       .notifier_call   = kgdb_panic_event,
 794       .priority        = INT_MAX,
 795};
 796
 797void __weak kgdb_arch_late(void)
 798{
 799}
 800
 801void __init dbg_late_init(void)
 802{
 803        dbg_is_early = false;
 804        if (kgdb_io_module_registered)
 805                kgdb_arch_late();
 806        kdb_init(KDB_INIT_FULL);
 807}
 808
 809static int
 810dbg_notify_reboot(struct notifier_block *this, unsigned long code, void *x)
 811{
 812        /*
 813         * Take the following action on reboot notify depending on value:
 814         *    1 == Enter debugger
 815         *    0 == [the default] detatch debug client
 816         *   -1 == Do nothing... and use this until the board resets
 817         */
 818        switch (kgdbreboot) {
 819        case 1:
 820                kgdb_breakpoint();
 821        case -1:
 822                goto done;
 823        }
 824        if (!dbg_kdb_mode)
 825                gdbstub_exit(code);
 826done:
 827        return NOTIFY_DONE;
 828}
 829
 830static struct notifier_block dbg_reboot_notifier = {
 831        .notifier_call          = dbg_notify_reboot,
 832        .next                   = NULL,
 833        .priority               = INT_MAX,
 834};
 835
 836static void kgdb_register_callbacks(void)
 837{
 838        if (!kgdb_io_module_registered) {
 839                kgdb_io_module_registered = 1;
 840                kgdb_arch_init();
 841                if (!dbg_is_early)
 842                        kgdb_arch_late();
 843                register_module_notifier(&dbg_module_load_nb);
 844                register_reboot_notifier(&dbg_reboot_notifier);
 845                atomic_notifier_chain_register(&panic_notifier_list,
 846                                               &kgdb_panic_event_nb);
 847#ifdef CONFIG_MAGIC_SYSRQ
 848                register_sysrq_key('g', &sysrq_dbg_op);
 849#endif
 850                if (kgdb_use_con && !kgdb_con_registered) {
 851                        register_console(&kgdbcons);
 852                        kgdb_con_registered = 1;
 853                }
 854        }
 855}
 856
 857static void kgdb_unregister_callbacks(void)
 858{
 859        /*
 860         * When this routine is called KGDB should unregister from the
 861         * panic handler and clean up, making sure it is not handling any
 862         * break exceptions at the time.
 863         */
 864        if (kgdb_io_module_registered) {
 865                kgdb_io_module_registered = 0;
 866                unregister_reboot_notifier(&dbg_reboot_notifier);
 867                unregister_module_notifier(&dbg_module_load_nb);
 868                atomic_notifier_chain_unregister(&panic_notifier_list,
 869                                               &kgdb_panic_event_nb);
 870                kgdb_arch_exit();
 871#ifdef CONFIG_MAGIC_SYSRQ
 872                unregister_sysrq_key('g', &sysrq_dbg_op);
 873#endif
 874                if (kgdb_con_registered) {
 875                        unregister_console(&kgdbcons);
 876                        kgdb_con_registered = 0;
 877                }
 878        }
 879}
 880
 881/*
 882 * There are times a tasklet needs to be used vs a compiled in
 883 * break point so as to cause an exception outside a kgdb I/O module,
 884 * such as is the case with kgdboe, where calling a breakpoint in the
 885 * I/O driver itself would be fatal.
 886 */
 887static void kgdb_tasklet_bpt(unsigned long ing)
 888{
 889        kgdb_breakpoint();
 890        atomic_set(&kgdb_break_tasklet_var, 0);
 891}
 892
 893static DECLARE_TASKLET(kgdb_tasklet_breakpoint, kgdb_tasklet_bpt, 0);
 894
 895void kgdb_schedule_breakpoint(void)
 896{
 897        if (atomic_read(&kgdb_break_tasklet_var) ||
 898                atomic_read(&kgdb_active) != -1 ||
 899                atomic_read(&kgdb_setting_breakpoint))
 900                return;
 901        atomic_inc(&kgdb_break_tasklet_var);
 902        tasklet_schedule(&kgdb_tasklet_breakpoint);
 903}
 904EXPORT_SYMBOL_GPL(kgdb_schedule_breakpoint);
 905
 906static void kgdb_initial_breakpoint(void)
 907{
 908        kgdb_break_asap = 0;
 909
 910        printk(KERN_CRIT "kgdb: Waiting for connection from remote gdb...\n");
 911        kgdb_breakpoint();
 912}
 913
 914/**
 915 *      kgdb_register_io_module - register KGDB IO module
 916 *      @new_dbg_io_ops: the io ops vector
 917 *
 918 *      Register it with the KGDB core.
 919 */
 920int kgdb_register_io_module(struct kgdb_io *new_dbg_io_ops)
 921{
 922        int err;
 923
 924        spin_lock(&kgdb_registration_lock);
 925
 926        if (dbg_io_ops) {
 927                spin_unlock(&kgdb_registration_lock);
 928
 929                printk(KERN_ERR "kgdb: Another I/O driver is already "
 930                                "registered with KGDB.\n");
 931                return -EBUSY;
 932        }
 933
 934        if (new_dbg_io_ops->init) {
 935                err = new_dbg_io_ops->init();
 936                if (err) {
 937                        spin_unlock(&kgdb_registration_lock);
 938                        return err;
 939                }
 940        }
 941
 942        dbg_io_ops = new_dbg_io_ops;
 943
 944        spin_unlock(&kgdb_registration_lock);
 945
 946        printk(KERN_INFO "kgdb: Registered I/O driver %s.\n",
 947               new_dbg_io_ops->name);
 948
 949        /* Arm KGDB now. */
 950        kgdb_register_callbacks();
 951
 952        if (kgdb_break_asap)
 953                kgdb_initial_breakpoint();
 954
 955        return 0;
 956}
 957EXPORT_SYMBOL_GPL(kgdb_register_io_module);
 958
 959/**
 960 *      kkgdb_unregister_io_module - unregister KGDB IO module
 961 *      @old_dbg_io_ops: the io ops vector
 962 *
 963 *      Unregister it with the KGDB core.
 964 */
 965void kgdb_unregister_io_module(struct kgdb_io *old_dbg_io_ops)
 966{
 967        BUG_ON(kgdb_connected);
 968
 969        /*
 970         * KGDB is no longer able to communicate out, so
 971         * unregister our callbacks and reset state.
 972         */
 973        kgdb_unregister_callbacks();
 974
 975        spin_lock(&kgdb_registration_lock);
 976
 977        WARN_ON_ONCE(dbg_io_ops != old_dbg_io_ops);
 978        dbg_io_ops = NULL;
 979
 980        spin_unlock(&kgdb_registration_lock);
 981
 982        printk(KERN_INFO
 983                "kgdb: Unregistered I/O driver %s, debugger disabled.\n",
 984                old_dbg_io_ops->name);
 985}
 986EXPORT_SYMBOL_GPL(kgdb_unregister_io_module);
 987
 988int dbg_io_get_char(void)
 989{
 990        int ret = dbg_io_ops->read_char();
 991        if (ret == NO_POLL_CHAR)
 992                return -1;
 993        if (!dbg_kdb_mode)
 994                return ret;
 995        if (ret == 127)
 996                return 8;
 997        return ret;
 998}
 999
1000/**
1001 * kgdb_breakpoint - generate breakpoint exception
1002 *
1003 * This function will generate a breakpoint exception.  It is used at the
1004 * beginning of a program to sync up with a debugger and can be used
1005 * otherwise as a quick means to stop program execution and "break" into
1006 * the debugger.
1007 */
1008void kgdb_breakpoint(void)
1009{
1010        atomic_inc(&kgdb_setting_breakpoint);
1011        wmb(); /* Sync point before breakpoint */
1012        arch_kgdb_breakpoint();
1013        wmb(); /* Sync point after breakpoint */
1014        atomic_dec(&kgdb_setting_breakpoint);
1015}
1016EXPORT_SYMBOL_GPL(kgdb_breakpoint);
1017
1018static int __init opt_kgdb_wait(char *str)
1019{
1020        kgdb_break_asap = 1;
1021
1022        kdb_init(KDB_INIT_EARLY);
1023        if (kgdb_io_module_registered)
1024                kgdb_initial_breakpoint();
1025
1026        return 0;
1027}
1028
1029early_param("kgdbwait", opt_kgdb_wait);
1030
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.