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