kernel/kgdb.c

   1 /*
   2  * KGDB stub.
   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@suse.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-2008 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/reboot.h>
  41 #include <linux/string.h>
  42 #include <linux/delay.h>
  43 #include <linux/sched.h>
  44 #include <linux/sysrq.h>
  45 #include <linux/init.h>
  46 #include <linux/kgdb.h>
  47 #include <linux/pid.h>
  48 #include <linux/smp.h>
  49 #include <linux/mm.h>
  50
  51 #include <asm/cacheflush.h>
  52 #include <asm/byteorder.h>
  53 #include <asm/atomic.h>
  54 #include <asm/system.h>
  55 #include <asm/unaligned.h>
  56
  57 static int kgdb_break_asap;
  58
  59 #define KGDB_MAX_THREAD_QUERY 17
  60 struct kgdb_state {
  61         int                     ex_vector;
  62         int                     signo;
  63         int                     err_code;
  64         int                     cpu;
  65         int                     pass_exception;
  66         unsigned long           thr_query;
  67         unsigned long           threadid;
  68         long                    kgdb_usethreadid;
  69         struct pt_regs          *linux_regs;
  70 };
  71
  72 /* Exception state values */
  73 #define DCPU_WANT_MASTER 0x1 /* Waiting to become a master kgdb cpu */
  74 #define DCPU_NEXT_MASTER 0x2 /* Transition from one master cpu to another */
  75 #define DCPU_IS_SLAVE    0x4 /* Slave cpu enter exception */
  76 #define DCPU_SSTEP       0x8 /* CPU is single stepping */
  77
  78 static struct debuggerinfo_struct {
  79         void                    *debuggerinfo;
  80         struct task_struct      *task;
  81         int                     exception_state;
  82 } kgdb_info[NR_CPUS];
  83
  84 /**
  85  * kgdb_connected - Is a host GDB connected to us?
  86  */
  87 int                             kgdb_connected;
  88 EXPORT_SYMBOL_GPL(kgdb_connected);
  89
  90 /* All the KGDB handlers are installed */
  91 static int                      kgdb_io_module_registered;
  92
  93 /* Guard for recursive entry */
  94 static int                      exception_level;
  95
  96 static struct kgdb_io           *kgdb_io_ops;
  97 static DEFINE_SPINLOCK(kgdb_registration_lock);
  98
  99 /* kgdb console driver is loaded */
 100 static int kgdb_con_registered;
 101 /* determine if kgdb console output should be used */
 102 static int kgdb_use_con;
 103
 104 static int __init opt_kgdb_con(char *str)
 105 {
 106         kgdb_use_con = 1;
 107         return 0;
 108 }
 109
 110 early_param("kgdbcon", opt_kgdb_con);
 111
 112 module_param(kgdb_use_con, int, 0644);
 113
 114 /*
 115  * Holds information about breakpoints in a kernel. These breakpoints are
 116  * added and removed by gdb.
 117  */
 118 static struct kgdb_bkpt         kgdb_break[KGDB_MAX_BREAKPOINTS] = {
 119         [0 ... KGDB_MAX_BREAKPOINTS-1] = { .state = BP_UNDEFINED }
 120 };
 121
 122 /*
 123  * The CPU# of the active CPU, or -1 if none:
 124  */
 125 atomic_t                        kgdb_active = ATOMIC_INIT(-1);
 126
 127 /*
 128  * We use NR_CPUs not PERCPU, in case kgdb is used to debug early
 129  * bootup code (which might not have percpu set up yet):
 130  */
 131 static atomic_t                 passive_cpu_wait[NR_CPUS];
 132 static atomic_t                 cpu_in_kgdb[NR_CPUS];
 133 atomic_t                        kgdb_setting_breakpoint;
 134
 135 struct task_struct              *kgdb_usethread;
 136 struct task_struct              *kgdb_contthread;
 137
 138 int                             kgdb_single_step;
 139 pid_t                           kgdb_sstep_pid;
 140
 141 /* Our I/O buffers. */
 142 static char                     remcom_in_buffer[BUFMAX];
 143 static char                     remcom_out_buffer[BUFMAX];
 144
 145 /* Storage for the registers, in GDB format. */
 146 static unsigned long            gdb_regs[(NUMREGBYTES +
 147                                         sizeof(unsigned long) - 1) /
 148                                         sizeof(unsigned long)];
 149
 150 /* to keep track of the CPU which is doing the single stepping*/
 151 atomic_t                        kgdb_cpu_doing_single_step = ATOMIC_INIT(-1);
 152
 153 /*
 154  * If you are debugging a problem where roundup (the collection of
 155  * all other CPUs) is a problem [this should be extremely rare],
 156  * then use the nokgdbroundup option to avoid roundup. In that case
 157  * the other CPUs might interfere with your debugging context, so
 158  * use this with care:
 159  */
 160 static int kgdb_do_roundup = 1;
 161
 162 static int __init opt_nokgdbroundup(char *str)
 163 {
 164         kgdb_do_roundup = 0;
 165
 166         return 0;
 167 }
 168
 169 early_param("nokgdbroundup", opt_nokgdbroundup);
 170
 171 /*
 172  * Finally, some KGDB code :-)
 173  */
 174
 175 /*
 176  * Weak aliases for breakpoint management,
 177  * can be overriden by architectures when needed:
 178  */
 179 int __weak kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr)
 180 {
 181         int err;
 182
 183         err = probe_kernel_read(saved_instr, (char *)addr, BREAK_INSTR_SIZE);
 184         if (err)
 185                 return err;
 186
 187         return probe_kernel_write((char *)addr, arch_kgdb_ops.gdb_bpt_instr,
 188                                   BREAK_INSTR_SIZE);
 189 }
 190
 191 int __weak kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle)
 192 {
 193         return probe_kernel_write((char *)addr,
 194                                   (char *)bundle, BREAK_INSTR_SIZE);
 195 }
 196
 197 int __weak kgdb_validate_break_address(unsigned long addr)
 198 {
 199         char tmp_variable[BREAK_INSTR_SIZE];
 200         int err;
 201         /* Validate setting the breakpoint and then removing it.  In the
 202          * remove fails, the kernel needs to emit a bad message because we
 203          * are deep trouble not being able to put things back the way we
 204          * found them.
 205          */
 206         err = kgdb_arch_set_breakpoint(addr, tmp_variable);
 207         if (err)
 208                 return err;
 209         err = kgdb_arch_remove_breakpoint(addr, tmp_variable);
 210         if (err)
 211                 printk(KERN_ERR "KGDB: Critical breakpoint error, kernel "
 212                    "memory destroyed at: %lx", addr);
 213         return err;
 214 }
 215
 216 unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs)
 217 {
 218         return instruction_pointer(regs);
 219 }
 220
 221 int __weak kgdb_arch_init(void)
 222 {
 223         return 0;
 224 }
 225
 226 int __weak kgdb_skipexception(int exception, struct pt_regs *regs)
 227 {
 228         return 0;
 229 }
 230
 231 void __weak
 232 kgdb_post_primary_code(struct pt_regs *regs, int e_vector, int err_code)
 233 {
 234         return;
 235 }
 236
 237 /**
 238  *      kgdb_disable_hw_debug - Disable hardware debugging while we in kgdb.
 239  *      @regs: Current &struct pt_regs.
 240  *
 241  *      This function will be called if the particular architecture must
 242  *      disable hardware debugging while it is processing gdb packets or
 243  *      handling exception.
 244  */
 245 void __weak kgdb_disable_hw_debug(struct pt_regs *regs)
 246 {
 247 }
 248
 249 /*
 250  * GDB remote protocol parser:
 251  */
 252
 253 static int hex(char ch)
 254 {
 255         if ((ch >= 'a') && (ch <= 'f'))
 256                 return ch - 'a' + 10;
 257         if ((ch >= '0') && (ch <= '9'))
 258                 return ch - '0';
 259         if ((ch >= 'A') && (ch <= 'F'))
 260                 return ch - 'A' + 10;
 261         return -1;
 262 }
 263
 264 /* scan for the sequence $<data>#<checksum> */
 265 static void get_packet(char *buffer)
 266 {
 267         unsigned char checksum;
 268         unsigned char xmitcsum;
 269         int count;
 270         char ch;
 271
 272         do {
 273                 /*
 274                  * Spin and wait around for the start character, ignore all
 275                  * other characters:
 276                  */
 277                 while ((ch = (kgdb_io_ops->read_char())) != '$')
 278                         /* nothing */;
 279
 280                 kgdb_connected = 1;
 281                 checksum = 0;
 282                 xmitcsum = -1;
 283
 284                 count = 0;
 285
 286                 /*
 287                  * now, read until a # or end of buffer is found:
 288                  */
 289                 while (count < (BUFMAX - 1)) {
 290                         ch = kgdb_io_ops->read_char();
 291                         if (ch == '#')
 292                                 break;
 293                         checksum = checksum + ch;
 294                         buffer[count] = ch;
 295                         count = count + 1;
 296                 }
 297                 buffer[count] = 0;
 298
 299                 if (ch == '#') {
 300                         xmitcsum = hex(kgdb_io_ops->read_char()) << 4;
 301                         xmitcsum += hex(kgdb_io_ops->read_char());
 302
 303                         if (checksum != xmitcsum)
 304                                 /* failed checksum */
 305                                 kgdb_io_ops->write_char('-');
 306                         else
 307                                 /* successful transfer */
 308                                 kgdb_io_ops->write_char('+');
 309                         if (kgdb_io_ops->flush)
 310                                 kgdb_io_ops->flush();
 311                 }
 312         } while (checksum != xmitcsum);
 313 }
 314
 315 /*
 316  * Send the packet in buffer.
 317  * Check for gdb connection if asked for.
 318  */
 319 static void put_packet(char *buffer)
 320 {
 321         unsigned char checksum;
 322         int count;
 323         char ch;
 324
 325         /*
 326          * $<packet info>#<checksum>.
 327          */
 328         while (1) {
 329                 kgdb_io_ops->write_char('$');
 330                 checksum = 0;
 331                 count = 0;
 332
 333                 while ((ch = buffer[count])) {
 334                         kgdb_io_ops->write_char(ch);
 335                         checksum += ch;
 336                         count++;
 337                 }
 338
 339                 kgdb_io_ops->write_char('#');
 340                 kgdb_io_ops->write_char(hex_asc_hi(checksum));
 341                 kgdb_io_ops->write_char(hex_asc_lo(checksum));
 342                 if (kgdb_io_ops->flush)
 343                         kgdb_io_ops->flush();
 344
 345                 /* Now see what we get in reply. */
 346                 ch = kgdb_io_ops->read_char();
 347
 348                 if (ch == 3)
 349                         ch = kgdb_io_ops->read_char();
 350
 351                 /* If we get an ACK, we are done. */
 352                 if (ch == '+')
 353                         return;
 354
 355                 /*
 356                  * If we get the start of another packet, this means
 357                  * that GDB is attempting to reconnect.  We will NAK
 358                  * the packet being sent, and stop trying to send this
 359                  * packet.
 360                  */
 361                 if (ch == '$') {
 362                         kgdb_io_ops->write_char('-');
 363                         if (kgdb_io_ops->flush)
 364                                 kgdb_io_ops->flush();
 365                         return;
 366                 }
 367         }
 368 }
 369
 370 /*
 371  * Convert the memory pointed to by mem into hex, placing result in buf.
 372  * Return a pointer to the last char put in buf (null). May return an error.
 373  */
 374 int kgdb_mem2hex(char *mem, char *buf, int count)
 375 {
 376         char *tmp;
 377         int err;
 378
 379         /*
 380          * We use the upper half of buf as an intermediate buffer for the
 381          * raw memory copy.  Hex conversion will work against this one.
 382          */
 383         tmp = buf + count;
 384
 385         err = probe_kernel_read(tmp, mem, count);
 386         if (!err) {
 387                 while (count > 0) {
 388                         buf = pack_hex_byte(buf, *tmp);
 389                         tmp++;
 390                         count--;
 391                 }
 392
 393                 *buf = 0;
 394         }
 395
 396         return err;
 397 }
 398
 399 /*
 400  * Copy the binary array pointed to by buf into mem.  Fix $, #, and
 401  * 0x7d escaped with 0x7d. Return -EFAULT on failure or 0 on success.
 402  * The input buf is overwitten with the result to write to mem.
 403  */
 404 static int kgdb_ebin2mem(char *buf, char *mem, int count)
 405 {
 406         int size = 0;
 407         char *c = buf;
 408
 409         while (count-- > 0) {
 410                 c[size] = *buf++;
 411                 if (c[size] == 0x7d)
 412                         c[size] = *buf++ ^ 0x20;
 413                 size++;
 414         }
 415
 416         return probe_kernel_write(mem, c, size);
 417 }
 418
 419 /*
 420  * Convert the hex array pointed to by buf into binary to be placed in mem.
 421  * Return a pointer to the character AFTER the last byte written.
 422  * May return an error.
 423  */
 424 int kgdb_hex2mem(char *buf, char *mem, int count)
 425 {
 426         char *tmp_raw;
 427         char *tmp_hex;
 428
 429         /*
 430          * We use the upper half of buf as an intermediate buffer for the
 431          * raw memory that is converted from hex.
 432          */
 433         tmp_raw = buf + count * 2;
 434
 435         tmp_hex = tmp_raw - 1;
 436         while (tmp_hex >= buf) {
 437                 tmp_raw--;
 438                 *tmp_raw = hex(*tmp_hex--);
 439                 *tmp_raw |= hex(*tmp_hex--) << 4;
 440         }
 441
 442         return probe_kernel_write(mem, tmp_raw, count);
 443 }
 444
 445 /*
 446  * While we find nice hex chars, build a long_val.
 447  * Return number of chars processed.
 448  */
 449 int kgdb_hex2long(char **ptr, unsigned long *long_val)
 450 {
 451         int hex_val;
 452         int num = 0;
 453         int negate = 0;
 454
 455         *long_val = 0;
 456
 457         if (**ptr == '-') {
 458                 negate = 1;
 459                 (*ptr)++;
 460         }
 461         while (**ptr) {
 462                 hex_val = hex(**ptr);
 463                 if (hex_val < 0)
 464                         break;
 465
 466                 *long_val = (*long_val << 4) | hex_val;
 467                 num++;
 468                 (*ptr)++;
 469         }
 470
 471         if (negate)
 472                 *long_val = -*long_val;
 473
 474         return num;
 475 }
 476
 477 /* Write memory due to an 'M' or 'X' packet. */
 478 static int write_mem_msg(int binary)
 479 {
 480         char *ptr = &remcom_in_buffer[1];
 481         unsigned long addr;
 482         unsigned long length;
 483         int err;
 484
 485         if (kgdb_hex2long(&ptr, &addr) > 0 && *(ptr++) == ',' &&
 486             kgdb_hex2long(&ptr, &length) > 0 && *(ptr++) == ':') {
 487                 if (binary)
 488                         err = kgdb_ebin2mem(ptr, (char *)addr, length);
 489                 else
 490                         err = kgdb_hex2mem(ptr, (char *)addr, length);
 491                 if (err)
 492                         return err;
 493                 if (CACHE_FLUSH_IS_SAFE)
 494                         flush_icache_range(addr, addr + length);
 495                 return 0;
 496         }
 497
 498         return -EINVAL;
 499 }
 500
 501 static void error_packet(char *pkt, int error)
 502 {
 503         error = -error;
 504         pkt[0] = 'E';
 505         pkt[1] = hex_asc[(error / 10)];
 506         pkt[2] = hex_asc[(error % 10)];
 507         pkt[3] = '\0';
 508 }
 509
 510 /*
 511  * Thread ID accessors. We represent a flat TID space to GDB, where
 512  * the per CPU idle threads (which under Linux all have PID 0) are
 513  * remapped to negative TIDs.
 514  */
 515
 516 #define BUF_THREAD_ID_SIZE      16
 517
 518 static char *pack_threadid(char *pkt, unsigned char *id)
 519 {
 520         char *limit;
 521
 522         limit = pkt + BUF_THREAD_ID_SIZE;
 523         while (pkt < limit)
 524                 pkt = pack_hex_byte(pkt, *id++);
 525
 526         return pkt;
 527 }
 528
 529 static void int_to_threadref(unsigned char *id, int value)
 530 {
 531         unsigned char *scan;
 532         int i = 4;
 533
 534         scan = (unsigned char *)id;
 535         while (i--)
 536                 *scan++ = 0;
 537         put_unaligned_be32(value, scan);
 538 }
 539
 540 static struct task_struct *getthread(struct pt_regs *regs, int tid)
 541 {
 542         /*
 543          * Non-positive TIDs are remapped to the cpu shadow information
 544          */
 545         if (tid == 0 || tid == -1)
 546                 tid = -atomic_read(&kgdb_active) - 2;
 547         if (tid < -1 && tid > -NR_CPUS - 2) {
 548                 if (kgdb_info[-tid - 2].task)
 549                         return kgdb_info[-tid - 2].task;
 550                 else
 551                         return idle_task(-tid - 2);
 552         }
 553         if (tid <= 0) {
 554                 printk(KERN_ERR "KGDB: Internal thread select error\n");
 555                 dump_stack();
 556                 return NULL;
 557         }
 558
 559         /*
 560          * find_task_by_pid_ns() does not take the tasklist lock anymore
 561          * but is nicely RCU locked - hence is a pretty resilient
 562          * thing to use:
 563          */
 564         return find_task_by_pid_ns(tid, &init_pid_ns);
 565 }
 566
 567 /*
 568  * Some architectures need cache flushes when we set/clear a
 569  * breakpoint:
 570  */
 571 static void kgdb_flush_swbreak_addr(unsigned long addr)
 572 {
 573         if (!CACHE_FLUSH_IS_SAFE)
 574                 return;
 575
 576         if (current->mm && current->mm->mmap_cache) {
 577                 flush_cache_range(current->mm->mmap_cache,
 578                                   addr, addr + BREAK_INSTR_SIZE);
 579         }
 580         /* Force flush instruction cache if it was outside the mm */
 581         flush_icache_range(addr, addr + BREAK_INSTR_SIZE);
 582 }
 583
 584 /*
 585  * SW breakpoint management:
 586  */
 587 static int kgdb_activate_sw_breakpoints(void)
 588 {
 589         unsigned long addr;
 590         int error;
 591         int ret = 0;
 592         int i;
 593
 594         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 595                 if (kgdb_break[i].state != BP_SET)
 596                         continue;
 597
 598                 addr = kgdb_break[i].bpt_addr;
 599                 error = kgdb_arch_set_breakpoint(addr,
 600                                 kgdb_break[i].saved_instr);
 601                 if (error) {
 602                         ret = error;
 603                         printk(KERN_INFO "KGDB: BP install failed: %lx", addr);
 604                         continue;
 605                 }
 606
 607                 kgdb_flush_swbreak_addr(addr);
 608                 kgdb_break[i].state = BP_ACTIVE;
 609         }
 610         return ret;
 611 }
 612
 613 static int kgdb_set_sw_break(unsigned long addr)
 614 {
 615         int err = kgdb_validate_break_address(addr);
 616         int breakno = -1;
 617         int i;
 618
 619         if (err)
 620                 return err;
 621
 622         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 623                 if ((kgdb_break[i].state == BP_SET) &&
 624                                         (kgdb_break[i].bpt_addr == addr))
 625                         return -EEXIST;
 626         }
 627         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 628                 if (kgdb_break[i].state == BP_REMOVED &&
 629                                         kgdb_break[i].bpt_addr == addr) {
 630                         breakno = i;
 631                         break;
 632                 }
 633         }
 634
 635         if (breakno == -1) {
 636                 for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 637                         if (kgdb_break[i].state == BP_UNDEFINED) {
 638                                 breakno = i;
 639                                 break;
 640                         }
 641                 }
 642         }
 643
 644         if (breakno == -1)
 645                 return -E2BIG;
 646
 647         kgdb_break[breakno].state = BP_SET;
 648         kgdb_break[breakno].type = BP_BREAKPOINT;
 649         kgdb_break[breakno].bpt_addr = addr;
 650
 651         return 0;
 652 }
 653
 654 static int kgdb_deactivate_sw_breakpoints(void)
 655 {
 656         unsigned long addr;
 657         int error;
 658         int ret = 0;
 659         int i;
 660
 661         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 662                 if (kgdb_break[i].state != BP_ACTIVE)
 663                         continue;
 664                 addr = kgdb_break[i].bpt_addr;
 665                 error = kgdb_arch_remove_breakpoint(addr,
 666                                         kgdb_break[i].saved_instr);
 667                 if (error) {
 668                         printk(KERN_INFO "KGDB: BP remove failed: %lx\n", addr);
 669                         ret = error;
 670                 }
 671
 672                 kgdb_flush_swbreak_addr(addr);
 673                 kgdb_break[i].state = BP_SET;
 674         }
 675         return ret;
 676 }
 677
 678 static int kgdb_remove_sw_break(unsigned long addr)
 679 {
 680         int i;
 681
 682         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 683                 if ((kgdb_break[i].state == BP_SET) &&
 684                                 (kgdb_break[i].bpt_addr == addr)) {
 685                         kgdb_break[i].state = BP_REMOVED;
 686                         return 0;
 687                 }
 688         }
 689         return -ENOENT;
 690 }
 691
 692 int kgdb_isremovedbreak(unsigned long addr)
 693 {
 694         int i;
 695
 696         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 697                 if ((kgdb_break[i].state == BP_REMOVED) &&
 698                                         (kgdb_break[i].bpt_addr == addr))
 699                         return 1;
 700         }
 701         return 0;
 702 }
 703
 704 static int remove_all_break(void)
 705 {
 706         unsigned long addr;
 707         int error;
 708         int i;
 709
 710         /* Clear memory breakpoints. */
 711         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
 712                 if (kgdb_break[i].state != BP_ACTIVE)
 713                         goto setundefined;
 714                 addr = kgdb_break[i].bpt_addr;
 715                 error = kgdb_arch_remove_breakpoint(addr,
 716                                 kgdb_break[i].saved_instr);
 717                 if (error)
 718                         printk(KERN_ERR "KGDB: breakpoint remove failed: %lx\n",
 719                            addr);
 720 setundefined:
 721                 kgdb_break[i].state = BP_UNDEFINED;
 722         }
 723
 724         /* Clear hardware breakpoints. */
 725         if (arch_kgdb_ops.remove_all_hw_break)
 726                 arch_kgdb_ops.remove_all_hw_break();
 727
 728         return 0;
 729 }
 730
 731 /*
 732  * Remap normal tasks to their real PID,
 733  * CPU shadow threads are mapped to -CPU - 2
 734  */
 735 static inline int shadow_pid(int realpid)
 736 {
 737         if (realpid)
 738                 return realpid;
 739
 740         return -raw_smp_processor_id() - 2;
 741 }
 742
 743 static char gdbmsgbuf[BUFMAX + 1];
 744
 745 static void kgdb_msg_write(const char *s, int len)
 746 {
 747         char *bufptr;
 748         int wcount;
 749         int i;
 750
 751         /* 'O'utput */
 752         gdbmsgbuf[0] = 'O';
 753
 754         /* Fill and send buffers... */
 755         while (len > 0) {
 756                 bufptr = gdbmsgbuf + 1;
 757
 758                 /* Calculate how many this time */
 759                 if ((len << 1) > (BUFMAX - 2))
 760                         wcount = (BUFMAX - 2) >> 1;
 761                 else
 762                         wcount = len;
 763
 764                 /* Pack in hex chars */
 765                 for (i = 0; i < wcount; i++)
 766                         bufptr = pack_hex_byte(bufptr, s[i]);
 767                 *bufptr = '\0';
 768
 769                 /* Move up */
 770                 s += wcount;
 771                 len -= wcount;
 772
 773                 /* Write packet */
 774                 put_packet(gdbmsgbuf);
 775         }
 776 }
 777
 778 /*
 779  * Return true if there is a valid kgdb I/O module.  Also if no
 780  * debugger is attached a message can be printed to the console about
 781  * waiting for the debugger to attach.
 782  *
 783  * The print_wait argument is only to be true when called from inside
 784  * the core kgdb_handle_exception, because it will wait for the
 785  * debugger to attach.
 786  */
 787 static int kgdb_io_ready(int print_wait)
 788 {
 789         if (!kgdb_io_ops)
 790                 return 0;
 791         if (kgdb_connected)
 792                 return 1;
 793         if (atomic_read(&kgdb_setting_breakpoint))
 794                 return 1;
 795         if (print_wait)
 796                 printk(KERN_CRIT "KGDB: Waiting for remote debugger\n");
 797         return 1;
 798 }
 799
 800 /*
 801  * All the functions that start with gdb_cmd are the various
 802  * operations to implement the handlers for the gdbserial protocol
 803  * where KGDB is communicating with an external debugger
 804  */
 805
 806 /* Handle the '?' status packets */
 807 static void gdb_cmd_status(struct kgdb_state *ks)
 808 {
 809         /*
 810          * We know that this packet is only sent
 811          * during initial connect.  So to be safe,
 812          * we clear out our breakpoints now in case
 813          * GDB is reconnecting.
 814          */
 815         remove_all_break();
 816
 817         remcom_out_buffer[0] = 'S';
 818         pack_hex_byte(&remcom_out_buffer[1], ks->signo);
 819 }
 820
 821 /* Handle the 'g' get registers request */
 822 static void gdb_cmd_getregs(struct kgdb_state *ks)
 823 {
 824         struct task_struct *thread;
 825         void *local_debuggerinfo;
 826         int i;
 827
 828         thread = kgdb_usethread;
 829         if (!thread) {
 830                 thread = kgdb_info[ks->cpu].task;
 831                 local_debuggerinfo = kgdb_info[ks->cpu].debuggerinfo;
 832         } else {
 833                 local_debuggerinfo = NULL;
 834                 for_each_online_cpu(i) {
 835                         /*
 836                          * Try to find the task on some other
 837                          * or possibly this node if we do not
 838                          * find the matching task then we try
 839                          * to approximate the results.
 840                          */
 841                         if (thread == kgdb_info[i].task)
 842                                 local_debuggerinfo = kgdb_info[i].debuggerinfo;
 843                 }
 844         }
 845
 846         /*
 847          * All threads that don't have debuggerinfo should be
 848          * in schedule() sleeping, since all other CPUs
 849          * are in kgdb_wait, and thus have debuggerinfo.
 850          */
 851         if (local_debuggerinfo) {
 852                 pt_regs_to_gdb_regs(gdb_regs, local_debuggerinfo);
 853         } else {
 854                 /*
 855                  * Pull stuff saved during switch_to; nothing
 856                  * else is accessible (or even particularly
 857                  * relevant).
 858                  *
 859                  * This should be enough for a stack trace.
 860                  */
 861                 sleeping_thread_to_gdb_regs(gdb_regs, thread);
 862         }
 863         kgdb_mem2hex((char *)gdb_regs, remcom_out_buffer, NUMREGBYTES);
 864 }
 865
 866 /* Handle the 'G' set registers request */
 867 static void gdb_cmd_setregs(struct kgdb_state *ks)
 868 {
 869         kgdb_hex2mem(&remcom_in_buffer[1], (char *)gdb_regs, NUMREGBYTES);
 870
 871         if (kgdb_usethread && kgdb_usethread != current) {
 872                 error_packet(remcom_out_buffer, -EINVAL);
 873         } else {
 874                 gdb_regs_to_pt_regs(gdb_regs, ks->linux_regs);
 875                 strcpy(remcom_out_buffer, "OK");
 876         }
 877 }
 878
 879 /* Handle the 'm' memory read bytes */
 880 static void gdb_cmd_memread(struct kgdb_state *ks)
 881 {
 882         char *ptr = &remcom_in_buffer[1];
 883         unsigned long length;
 884         unsigned long addr;
 885         int err;
 886
 887         if (kgdb_hex2long(&ptr, &addr) > 0 && *ptr++ == ',' &&
 888                                         kgdb_hex2long(&ptr, &length) > 0) {
 889                 err = kgdb_mem2hex((char *)addr, remcom_out_buffer, length);
 890                 if (err)
 891                         error_packet(remcom_out_buffer, err);
 892         } else {
 893                 error_packet(remcom_out_buffer, -EINVAL);
 894         }
 895 }
 896
 897 /* Handle the 'M' memory write bytes */
 898 static void gdb_cmd_memwrite(struct kgdb_state *ks)
 899 {
 900         int err = write_mem_msg(0);
 901
 902         if (err)
 903                 error_packet(remcom_out_buffer, err);
 904         else
 905                 strcpy(remcom_out_buffer, "OK");
 906 }
 907
 908 /* Handle the 'X' memory binary write bytes */
 909 static void gdb_cmd_binwrite(struct kgdb_state *ks)
 910 {
 911         int err = write_mem_msg(1);
 912
 913         if (err)
 914                 error_packet(remcom_out_buffer, err);
 915         else
 916                 strcpy(remcom_out_buffer, "OK");
 917 }
 918
 919 /* Handle the 'D' or 'k', detach or kill packets */
 920 static void gdb_cmd_detachkill(struct kgdb_state *ks)
 921 {
 922         int error;
 923
 924         /* The detach case */
 925         if (remcom_in_buffer[0] == 'D') {
 926                 error = remove_all_break();
 927                 if (error < 0) {
 928                         error_packet(remcom_out_buffer, error);
 929                 } else {
 930                         strcpy(remcom_out_buffer, "OK");
 931                         kgdb_connected = 0;
 932                 }
 933                 put_packet(remcom_out_buffer);
 934         } else {
 935                 /*
 936                  * Assume the kill case, with no exit code checking,
 937                  * trying to force detach the debugger:
 938                  */
 939                 remove_all_break();
 940                 kgdb_connected = 0;
 941         }
 942 }
 943
 944 /* Handle the 'R' reboot packets */
 945 static int gdb_cmd_reboot(struct kgdb_state *ks)
 946 {
 947         /* For now, only honor R0 */
 948         if (strcmp(remcom_in_buffer, "R0") == 0) {
 949                 printk(KERN_CRIT "Executing emergency reboot\n");
 950                 strcpy(remcom_out_buffer, "OK");
 951                 put_packet(remcom_out_buffer);
 952
 953                 /*
 954                  * Execution should not return from
 955                  * machine_emergency_restart()
 956                  */
 957                 machine_emergency_restart();
 958                 kgdb_connected = 0;
 959
 960                 return 1;
 961         }
 962         return 0;
 963 }
 964
 965 /* Handle the 'q' query packets */
 966 static void gdb_cmd_query(struct kgdb_state *ks)
 967 {
 968         struct task_struct *g;
 969         struct task_struct *p;
 970         unsigned char thref[8];
 971         char *ptr;
 972         int i;
 973         int cpu;
 974         int finished = 0;
 975
 976         switch (remcom_in_buffer[1]) {
 977         case 's':
 978         case 'f':
 979                 if (memcmp(remcom_in_buffer + 2, "ThreadInfo", 10)) {
 980                         error_packet(remcom_out_buffer, -EINVAL);
 981                         break;
 982                 }
 983
 984                 i = 0;
 985                 remcom_out_buffer[0] = 'm';
 986                 ptr = remcom_out_buffer + 1;
 987                 if (remcom_in_buffer[1] == 'f') {
 988                         /* Each cpu is a shadow thread */
 989                         for_each_online_cpu(cpu) {
 990                                 ks->thr_query = 0;
 991                                 int_to_threadref(thref, -cpu - 2);
 992                                 pack_threadid(ptr, thref);
 993                                 ptr += BUF_THREAD_ID_SIZE;
 994                                 *(ptr++) = ',';
 995                                 i++;
 996                         }
 997                 }
 998
 999                 do_each_thread(g, p) {
1000                         if (i >= ks->thr_query && !finished) {
1001                                 int_to_threadref(thref, p->pid);
1002                                 pack_threadid(ptr, thref);
1003                                 ptr += BUF_THREAD_ID_SIZE;
1004                                 *(ptr++) = ',';
1005                                 ks->thr_query++;
1006                                 if (ks->thr_query % KGDB_MAX_THREAD_QUERY == 0)
1007                                         finished = 1;
1008                         }
1009                         i++;
1010                 } while_each_thread(g, p);
1011
1012                 *(--ptr) = '\0';
1013                 break;
1014
1015         case 'C':
1016                 /* Current thread id */
1017                 strcpy(remcom_out_buffer, "QC");
1018                 ks->threadid = shadow_pid(current->pid);
1019                 int_to_threadref(thref, ks->threadid);
1020                 pack_threadid(remcom_out_buffer + 2, thref);
1021                 break;
1022         case 'T':
1023                 if (memcmp(remcom_in_buffer + 1, "ThreadExtraInfo,", 16)) {
1024                         error_packet(remcom_out_buffer, -EINVAL);
1025                         break;
1026                 }
1027                 ks->threadid = 0;
1028                 ptr = remcom_in_buffer + 17;
1029                 kgdb_hex2long(&ptr, &ks->threadid);
1030                 if (!getthread(ks->linux_regs, ks->threadid)) {
1031                         error_packet(remcom_out_buffer, -EINVAL);
1032                         break;
1033                 }
1034                 if ((int)ks->threadid > 0) {
1035                         kgdb_mem2hex(getthread(ks->linux_regs,
1036                                         ks->threadid)->comm,
1037                                         remcom_out_buffer, 16);
1038                 } else {
1039                         static char tmpstr[23 + BUF_THREAD_ID_SIZE];
1040
1041                         sprintf(tmpstr, "shadowCPU%d",
1042                                         (int)(-ks->threadid - 2));
1043                         kgdb_mem2hex(tmpstr, remcom_out_buffer, strlen(tmpstr));
1044                 }
1045                 break;
1046         }
1047 }
1048
1049 /* Handle the 'H' task query packets */
1050 static void gdb_cmd_task(struct kgdb_state *ks)
1051 {
1052         struct task_struct *thread;
1053         char *ptr;
1054
1055         switch (remcom_in_buffer[1]) {
1056         case 'g':
1057                 ptr = &remcom_in_buffer[2];
1058                 kgdb_hex2long(&ptr, &ks->threadid);
1059                 thread = getthread(ks->linux_regs, ks->threadid);
1060                 if (!thread && ks->threadid > 0) {
1061                         error_packet(remcom_out_buffer, -EINVAL);
1062                         break;
1063                 }
1064                 kgdb_usethread = thread;
1065                 ks->kgdb_usethreadid = ks->threadid;
1066                 strcpy(remcom_out_buffer, "OK");
1067                 break;
1068         case 'c':
1069                 ptr = &remcom_in_buffer[2];
1070                 kgdb_hex2long(&ptr, &ks->threadid);
1071                 if (!ks->threadid) {
1072                         kgdb_contthread = NULL;
1073                 } else {
1074                         thread = getthread(ks->linux_regs, ks->threadid);
1075                         if (!thread && ks->threadid > 0) {
1076                                 error_packet(remcom_out_buffer, -EINVAL);
1077                                 break;
1078                         }
1079                         kgdb_contthread = thread;
1080                 }
1081                 strcpy(remcom_out_buffer, "OK");
1082                 break;
1083         }
1084 }
1085
1086 /* Handle the 'T' thread query packets */
1087 static void gdb_cmd_thread(struct kgdb_state *ks)
1088 {
1089         char *ptr = &remcom_in_buffer[1];
1090         struct task_struct *thread;
1091
1092         kgdb_hex2long(&ptr, &ks->threadid);
1093         thread = getthread(ks->linux_regs, ks->threadid);
1094         if (thread)
1095                 strcpy(remcom_out_buffer, "OK");
1096         else
1097                 error_packet(remcom_out_buffer, -EINVAL);
1098 }
1099
1100 /* Handle the 'z' or 'Z' breakpoint remove or set packets */
1101 static void gdb_cmd_break(struct kgdb_state *ks)
1102 {
1103         /*
1104          * Since GDB-5.3, it's been drafted that '0' is a software
1105          * breakpoint, '1' is a hardware breakpoint, so let's do that.
1106          */
1107         char *bpt_type = &remcom_in_buffer[1];
1108         char *ptr = &remcom_in_buffer[2];
1109         unsigned long addr;
1110         unsigned long length;
1111         int error = 0;
1112
1113         if (arch_kgdb_ops.set_hw_breakpoint && *bpt_type >= '1') {
1114                 /* Unsupported */
1115                 if (*bpt_type > '4')
1116                         return;
1117         } else {
1118                 if (*bpt_type != '0' && *bpt_type != '1')
1119                         /* Unsupported. */
1120                         return;
1121         }
1122
1123         /*
1124          * Test if this is a hardware breakpoint, and
1125          * if we support it:
1126          */
1127         if (*bpt_type == '1' && !(arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT))
1128                 /* Unsupported. */
1129                 return;
1130
1131         if (*(ptr++) != ',') {
1132                 error_packet(remcom_out_buffer, -EINVAL);
1133                 return;
1134         }
1135         if (!kgdb_hex2long(&ptr, &addr)) {
1136                 error_packet(remcom_out_buffer, -EINVAL);
1137                 return;
1138         }
1139         if (*(ptr++) != ',' ||
1140                 !kgdb_hex2long(&ptr, &length)) {
1141                 error_packet(remcom_out_buffer, -EINVAL);
1142                 return;
1143         }
1144
1145         if (remcom_in_buffer[0] == 'Z' && *bpt_type == '0')
1146                 error = kgdb_set_sw_break(addr);
1147         else if (remcom_in_buffer[0] == 'z' && *bpt_type == '0')
1148                 error = kgdb_remove_sw_break(addr);
1149         else if (remcom_in_buffer[0] == 'Z')
1150                 error = arch_kgdb_ops.set_hw_breakpoint(addr,
1151                         (int)length, *bpt_type - '0');
1152         else if (remcom_in_buffer[0] == 'z')
1153                 error = arch_kgdb_ops.remove_hw_breakpoint(addr,
1154                         (int) length, *bpt_type - '0');
1155
1156         if (error == 0)
1157                 strcpy(remcom_out_buffer, "OK");
1158         else
1159                 error_packet(remcom_out_buffer, error);
1160 }
1161
1162 /* Handle the 'C' signal / exception passing packets */
1163 static int gdb_cmd_exception_pass(struct kgdb_state *ks)
1164 {
1165         /* C09 == pass exception
1166          * C15 == detach kgdb, pass exception
1167          */
1168         if (remcom_in_buffer[1] == '0' && remcom_in_buffer[2] == '9') {
1169
1170                 ks->pass_exception = 1;
1171                 remcom_in_buffer[0] = 'c';
1172
1173         } else if (remcom_in_buffer[1] == '1' && remcom_in_buffer[2] == '5') {
1174
1175                 ks->pass_exception = 1;
1176                 remcom_in_buffer[0] = 'D';
1177                 remove_all_break();
1178                 kgdb_connected = 0;
1179                 return 1;
1180
1181         } else {
1182                 kgdb_msg_write("KGDB only knows signal 9 (pass)"
1183                         " and 15 (pass and disconnect)\n"
1184                         "Executing a continue without signal passing\n", 0);
1185                 remcom_in_buffer[0] = 'c';
1186         }
1187
1188         /* Indicate fall through */
1189         return -1;
1190 }
1191
1192 /*
1193  * This function performs all gdbserial command procesing
1194  */
1195 static int gdb_serial_stub(struct kgdb_state *ks)
1196 {
1197         int error = 0;
1198         int tmp;
1199
1200         /* Clear the out buffer. */
1201         memset(remcom_out_buffer, 0, sizeof(remcom_out_buffer));
1202
1203         if (kgdb_connected) {
1204                 unsigned char thref[8];
1205                 char *ptr;
1206
1207                 /* Reply to host that an exception has occurred */
1208                 ptr = remcom_out_buffer;
1209                 *ptr++ = 'T';
1210                 ptr = pack_hex_byte(ptr, ks->signo);
1211                 ptr += strlen(strcpy(ptr, "thread:"));
1212                 int_to_threadref(thref, shadow_pid(current->pid));
1213                 ptr = pack_threadid(ptr, thref);
1214                 *ptr++ = ';';
1215                 put_packet(remcom_out_buffer);
1216         }
1217
1218         kgdb_usethread = kgdb_info[ks->cpu].task;
1219         ks->kgdb_usethreadid = shadow_pid(kgdb_info[ks->cpu].task->pid);
1220         ks->pass_exception = 0;
1221
1222         while (1) {
1223                 error = 0;
1224
1225                 /* Clear the out buffer. */
1226                 memset(remcom_out_buffer, 0, sizeof(remcom_out_buffer));
1227
1228                 get_packet(remcom_in_buffer);
1229
1230                 switch (remcom_in_buffer[0]) {
1231                 case '?': /* gdbserial status */
1232                         gdb_cmd_status(ks);
1233                         break;
1234                 case 'g': /* return the value of the CPU registers */
1235                         gdb_cmd_getregs(ks);
1236                         break;
1237                 case 'G': /* set the value of the CPU registers - return OK */
1238                         gdb_cmd_setregs(ks);
1239                         break;
1240                 case 'm': /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
1241                         gdb_cmd_memread(ks);
1242                         break;
1243                 case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA..AA */
1244                         gdb_cmd_memwrite(ks);
1245                         break;
1246                 case 'X': /* XAA..AA,LLLL: Write LLLL bytes at address AA..AA */
1247                         gdb_cmd_binwrite(ks);
1248                         break;
1249                         /* kill or detach. KGDB should treat this like a
1250                          * continue.
1251                          */
1252                 case 'D': /* Debugger detach */
1253                 case 'k': /* Debugger detach via kill */
1254                         gdb_cmd_detachkill(ks);
1255                         goto default_handle;
1256                 case 'R': /* Reboot */
1257                         if (gdb_cmd_reboot(ks))
1258                                 goto default_handle;
1259                         break;
1260                 case 'q': /* query command */
1261                         gdb_cmd_query(ks);
1262                         break;
1263                 case 'H': /* task related */
1264                         gdb_cmd_task(ks);
1265                         break;
1266                 case 'T': /* Query thread status */
1267                         gdb_cmd_thread(ks);
1268                         break;
1269                 case 'z': /* Break point remove */
1270                 case 'Z': /* Break point set */
1271                         gdb_cmd_break(ks);
1272                         break;
1273                 case 'C': /* Exception passing */
1274                         tmp = gdb_cmd_exception_pass(ks);
1275                         if (tmp > 0)
1276                                 goto default_handle;
1277                         if (tmp == 0)
1278                                 break;
1279                         /* Fall through on tmp < 0 */
1280                 case 'c': /* Continue packet */
1281                 case 's': /* Single step packet */
1282                         if (kgdb_contthread && kgdb_contthread != current) {
1283                                 /* Can't switch threads in kgdb */
1284                                 error_packet(remcom_out_buffer, -EINVAL);
1285                                 break;
1286                         }
1287                         kgdb_activate_sw_breakpoints();
1288                         /* Fall through to default processing */
1289                 default:
1290 default_handle:
1291                         error = kgdb_arch_handle_exception(ks->ex_vector,
1292                                                 ks->signo,
1293                                                 ks->err_code,
1294                                                 remcom_in_buffer,
1295                                                 remcom_out_buffer,
1296                                                 ks->linux_regs);
1297                         /*
1298                          * Leave cmd processing on error, detach,
1299                          * kill, continue, or single step.
1300                          */
1301                         if (error >= 0 || remcom_in_buffer[0] == 'D' ||
1302                             remcom_in_buffer[0] == 'k') {
1303                                 error = 0;
1304                                 goto kgdb_exit;
1305                         }
1306
1307                 }
1308
1309                 /* reply to the request */
1310                 put_packet(remcom_out_buffer);
1311         }
1312
1313 kgdb_exit:
1314         if (ks->pass_exception)
1315                 error = 1;
1316         return error;
1317 }
1318
1319 static int kgdb_reenter_check(struct kgdb_state *ks)
1320 {
1321         unsigned long addr;
1322
1323         if (atomic_read(&kgdb_active) != raw_smp_processor_id())
1324                 return 0;
1325
1326         /* Panic on recursive debugger calls: */
1327         exception_level++;
1328         addr = kgdb_arch_pc(ks->ex_vector, ks->linux_regs);
1329         kgdb_deactivate_sw_breakpoints();
1330
1331         /*
1332          * If the break point removed ok at the place exception
1333          * occurred, try to recover and print a warning to the end
1334          * user because the user planted a breakpoint in a place that
1335          * KGDB needs in order to function.
1336          */
1337         if (kgdb_remove_sw_break(addr) == 0) {
1338                 exception_level = 0;
1339                 kgdb_skipexception(ks->ex_vector, ks->linux_regs);
1340                 kgdb_activate_sw_breakpoints();
1341                 printk(KERN_CRIT "KGDB: re-enter error: breakpoint removed %lx\n",
1342                         addr);
1343                 WARN_ON_ONCE(1);
1344
1345                 return 1;
1346         }
1347         remove_all_break();
1348         kgdb_skipexception(ks->ex_vector, ks->linux_regs);
1349
1350         if (exception_level > 1) {
1351                 dump_stack();
1352                 panic("Recursive entry to debugger");
1353         }
1354
1355         printk(KERN_CRIT "KGDB: re-enter exception: ALL breakpoints killed\n");
1356         dump_stack();
1357         panic("Recursive entry to debugger");
1358
1359         return 1;
1360 }
1361
1362 static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs)
1363 {
1364         unsigned long flags;
1365         int sstep_tries = 100;
1366         int error = 0;
1367         int i, cpu;
1368         int trace_on = 0;
1369 acquirelock:
1370         /*
1371          * Interrupts will be restored by the 'trap return' code, except when
1372          * single stepping.
1373          */
1374         local_irq_save(flags);
1375
1376         cpu = ks->cpu;
1377         kgdb_info[cpu].debuggerinfo = regs;
1378         kgdb_info[cpu].task = current;
1379         /*
1380          * Make sure the above info reaches the primary CPU before
1381          * our cpu_in_kgdb[] flag setting does:
1382          */
1383         atomic_inc(&cpu_in_kgdb[cpu]);
1384
1385         /*
1386          * CPU will loop if it is a slave or request to become a kgdb
1387          * master cpu and acquire the kgdb_active lock:
1388          */
1389         while (1) {
1390                 if (kgdb_info[cpu].exception_state & DCPU_WANT_MASTER) {
1391                         if (atomic_cmpxchg(&kgdb_active, -1, cpu) == cpu)
1392                                 break;
1393                 } else if (kgdb_info[cpu].exception_state & DCPU_IS_SLAVE) {
1394                         if (!atomic_read(&passive_cpu_wait[cpu]))
1395                                 goto return_normal;
1396                 } else {
1397 return_normal:
1398                         /* Return to normal operation by executing any
1399                          * hw breakpoint fixup.
1400                          */
1401                         if (arch_kgdb_ops.correct_hw_break)
1402                                 arch_kgdb_ops.correct_hw_break();
1403                         if (trace_on)
1404                                 tracing_on();
1405                         atomic_dec(&cpu_in_kgdb[cpu]);
1406                         touch_softlockup_watchdog_sync();
1407                         clocksource_touch_watchdog();
1408                         local_irq_restore(flags);
1409                         return 0;
1410                 }
1411                 cpu_relax();
1412         }
1413
1414         /*
1415          * For single stepping, try to only enter on the processor
1416          * that was single stepping.  To gaurd against a deadlock, the
1417          * kernel will only try for the value of sstep_tries before
1418          * giving up and continuing on.
1419          */
1420         if (atomic_read(&kgdb_cpu_doing_single_step) != -1 &&
1421             (kgdb_info[cpu].task &&
1422              kgdb_info[cpu].task->pid != kgdb_sstep_pid) && --sstep_tries) {
1423                 atomic_set(&kgdb_active, -1);
1424                 touch_softlockup_watchdog_sync();
1425                 clocksource_touch_watchdog();
1426                 local_irq_restore(flags);
1427
1428                 goto acquirelock;
1429         }
1430
1431         if (!kgdb_io_ready(1)) {
1432                 error = 1;
1433                 goto kgdb_restore; /* No I/O connection, so resume the system */
1434         }
1435
1436         /*
1437          * Don't enter if we have hit a removed breakpoint.
1438          */
1439         if (kgdb_skipexception(ks->ex_vector, ks->linux_regs))
1440                 goto kgdb_restore;
1441
1442         /* Call the I/O driver's pre_exception routine */
1443         if (kgdb_io_ops->pre_exception)
1444                 kgdb_io_ops->pre_exception();
1445
1446         kgdb_disable_hw_debug(ks->linux_regs);
1447
1448         /*
1449          * Get the passive CPU lock which will hold all the non-primary
1450          * CPU in a spin state while the debugger is active
1451          */
1452         if (!kgdb_single_step) {
1453                 for (i = 0; i < NR_CPUS; i++)
1454                         atomic_inc(&passive_cpu_wait[i]);
1455         }
1456
1457 #ifdef CONFIG_SMP
1458         /* Signal the other CPUs to enter kgdb_wait() */
1459         if ((!kgdb_single_step) && kgdb_do_roundup)
1460                 kgdb_roundup_cpus(flags);
1461 #endif
1462
1463         /*
1464          * Wait for the other CPUs to be notified and be waiting for us:
1465          */
1466         for_each_online_cpu(i) {
1467                 while (!atomic_read(&cpu_in_kgdb[i]))
1468                         cpu_relax();
1469         }
1470
1471         /*
1472          * At this point the primary processor is completely
1473          * in the debugger and all secondary CPUs are quiescent
1474          */
1475         kgdb_post_primary_code(ks->linux_regs, ks->ex_vector, ks->err_code);
1476         kgdb_deactivate_sw_breakpoints();
1477         kgdb_single_step = 0;
1478         kgdb_contthread = current;
1479         exception_level = 0;
1480         trace_on = tracing_is_on();
1481         if (trace_on)
1482                 tracing_off();
1483
1484         /* Talk to debugger with gdbserial protocol */
1485         error = gdb_serial_stub(ks);
1486
1487         /* Call the I/O driver's post_exception routine */
1488         if (kgdb_io_ops->post_exception)
1489                 kgdb_io_ops->post_exception();
1490
1491         atomic_dec(&cpu_in_kgdb[ks->cpu]);
1492
1493         if (!kgdb_single_step) {
1494                 for (i = NR_CPUS-1; i >= 0; i--)
1495                         atomic_dec(&passive_cpu_wait[i]);
1496                 /*
1497                  * Wait till all the CPUs have quit
1498                  * from the debugger.
1499                  */
1500                 for_each_online_cpu(i) {
1501                         while (atomic_read(&cpu_in_kgdb[i]))
1502                                 cpu_relax();
1503                 }
1504         }
1505
1506 kgdb_restore:
1507         if (atomic_read(&kgdb_cpu_doing_single_step) != -1) {
1508                 int sstep_cpu = atomic_read(&kgdb_cpu_doing_single_step);
1509                 if (kgdb_info[sstep_cpu].task)
1510                         kgdb_sstep_pid = kgdb_info[sstep_cpu].task->pid;
1511                 else
1512                         kgdb_sstep_pid = 0;
1513         }
1514         if (trace_on)
1515                 tracing_on();
1516         /* Free kgdb_active */
1517         atomic_set(&kgdb_active, -1);
1518         touch_softlockup_watchdog_sync();
1519         clocksource_touch_watchdog();
1520         local_irq_restore(flags);
1521
1522         return error;
1523 }
1524
1525 /*
1526  * kgdb_handle_exception() - main entry point from a kernel exception
1527  *
1528  * Locking hierarchy:
1529  *      interface locks, if any (begin_session)
1530  *      kgdb lock (kgdb_active)
1531  */
1532 int
1533 kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
1534 {
1535         struct kgdb_state kgdb_var;
1536         struct kgdb_state *ks = &kgdb_var;
1537         int ret;
1538
1539         ks->cpu                 = raw_smp_processor_id();
1540         ks->ex_vector           = evector;
1541         ks->signo               = signo;
1542         ks->ex_vector           = evector;
1543         ks->err_code            = ecode;
1544         ks->kgdb_usethreadid    = 0;
1545         ks->linux_regs          = regs;
1546
1547         if (kgdb_reenter_check(ks))
1548                 return 0; /* Ouch, double exception ! */
1549         kgdb_info[ks->cpu].exception_state |= DCPU_WANT_MASTER;
1550         ret = kgdb_cpu_enter(ks, regs);
1551         kgdb_info[ks->cpu].exception_state &= ~DCPU_WANT_MASTER;
1552         return ret;
1553 }
1554
1555 int kgdb_nmicallback(int cpu, void *regs)
1556 {
1557 #ifdef CONFIG_SMP
1558         struct kgdb_state kgdb_var;
1559         struct kgdb_state *ks = &kgdb_var;
1560
1561         memset(ks, 0, sizeof(struct kgdb_state));
1562         ks->cpu                 = cpu;
1563         ks->linux_regs          = regs;
1564
1565         if (!atomic_read(&cpu_in_kgdb[cpu]) &&
1566             atomic_read(&kgdb_active) != -1 &&
1567             atomic_read(&kgdb_active) != cpu) {
1568                 kgdb_info[cpu].exception_state |= DCPU_IS_SLAVE;
1569                 kgdb_cpu_enter(ks, regs);
1570                 kgdb_info[cpu].exception_state &= ~DCPU_IS_SLAVE;
1571                 return 0;
1572         }
1573 #endif
1574         return 1;
1575 }
1576
1577 static void kgdb_console_write(struct console *co, const char *s,
1578    unsigned count)
1579 {
1580         unsigned long flags;
1581
1582         /* If we're debugging, or KGDB has not connected, don't try
1583          * and print. */
1584         if (!kgdb_connected || atomic_read(&kgdb_active) != -1)
1585                 return;
1586
1587         local_irq_save(flags);
1588         kgdb_msg_write(s, count);
1589         local_irq_restore(flags);
1590 }
1591
1592 static struct console kgdbcons = {
1593         .name           = "kgdb",
1594         .write          = kgdb_console_write,
1595         .flags          = CON_PRINTBUFFER | CON_ENABLED,
1596         .index          = -1,
1597 };
1598
1599 #ifdef CONFIG_MAGIC_SYSRQ
1600 static void sysrq_handle_gdb(int key, struct tty_struct *tty)
1601 {
1602         if (!kgdb_io_ops) {
1603                 printk(KERN_CRIT "ERROR: No KGDB I/O module available\n");
1604                 return;
1605         }
1606         if (!kgdb_connected)
1607                 printk(KERN_CRIT "Entering KGDB\n");
1608
1609         kgdb_breakpoint();
1610 }
1611
1612 static struct sysrq_key_op sysrq_gdb_op = {
1613         .handler        = sysrq_handle_gdb,
1614         .help_msg       = "debug(G)",
1615         .action_msg     = "DEBUG",
1616 };
1617 #endif
1618
1619 static void kgdb_register_callbacks(void)
1620 {
1621         if (!kgdb_io_module_registered) {
1622                 kgdb_io_module_registered = 1;
1623                 kgdb_arch_init();
1624 #ifdef CONFIG_MAGIC_SYSRQ
1625                 register_sysrq_key('g', &sysrq_gdb_op);
1626 #endif
1627                 if (kgdb_use_con && !kgdb_con_registered) {
1628                         register_console(&kgdbcons);
1629                         kgdb_con_registered = 1;
1630                 }
1631         }
1632 }
1633
1634 static void kgdb_unregister_callbacks(void)
1635 {
1636         /*
1637          * When this routine is called KGDB should unregister from the
1638          * panic handler and clean up, making sure it is not handling any
1639          * break exceptions at the time.
1640          */
1641         if (kgdb_io_module_registered) {
1642                 kgdb_io_module_registered = 0;
1643                 kgdb_arch_exit();
1644 #ifdef CONFIG_MAGIC_SYSRQ
1645                 unregister_sysrq_key('g', &sysrq_gdb_op);
1646 #endif
1647                 if (kgdb_con_registered) {
1648                         unregister_console(&kgdbcons);
1649                         kgdb_con_registered = 0;
1650                 }
1651         }
1652 }
1653
1654 static void kgdb_initial_breakpoint(void)
1655 {
1656         kgdb_break_asap = 0;
1657
1658         printk(KERN_CRIT "kgdb: Waiting for connection from remote gdb...\n");
1659         kgdb_breakpoint();
1660 }
1661
1662 /**
1663  *      kgdb_register_io_module - register KGDB IO module
1664  *      @new_kgdb_io_ops: the io ops vector
1665  *
1666  *      Register it with the KGDB core.
1667  */
1668 int kgdb_register_io_module(struct kgdb_io *new_kgdb_io_ops)
1669 {
1670         int err;
1671
1672         spin_lock(&kgdb_registration_lock);
1673
1674         if (kgdb_io_ops) {
1675                 spin_unlock(&kgdb_registration_lock);
1676
1677                 printk(KERN_ERR "kgdb: Another I/O driver is already "
1678                                 "registered with KGDB.\n");
1679                 return -EBUSY;
1680         }
1681
1682         if (new_kgdb_io_ops->init) {
1683                 err = new_kgdb_io_ops->init();
1684                 if (err) {
1685                         spin_unlock(&kgdb_registration_lock);
1686                         return err;
1687                 }
1688         }
1689
1690         kgdb_io_ops = new_kgdb_io_ops;
1691
1692         spin_unlock(&kgdb_registration_lock);
1693
1694         printk(KERN_INFO "kgdb: Registered I/O driver %s.\n",
1695                new_kgdb_io_ops->name);
1696
1697         /* Arm KGDB now. */
1698         kgdb_register_callbacks();
1699
1700         if (kgdb_break_asap)
1701                 kgdb_initial_breakpoint();
1702
1703         return 0;
1704 }
1705 EXPORT_SYMBOL_GPL(kgdb_register_io_module);
1706
1707 /**
1708  *      kkgdb_unregister_io_module - unregister KGDB IO module
1709  *      @old_kgdb_io_ops: the io ops vector
1710  *
1711  *      Unregister it with the KGDB core.
1712  */
1713 void kgdb_unregister_io_module(struct kgdb_io *old_kgdb_io_ops)
1714 {
1715         BUG_ON(kgdb_connected);
1716
1717         /*
1718          * KGDB is no longer able to communicate out, so
1719          * unregister our callbacks and reset state.
1720          */
1721         kgdb_unregister_callbacks();
1722
1723         spin_lock(&kgdb_registration_lock);
1724
1725         WARN_ON_ONCE(kgdb_io_ops != old_kgdb_io_ops);
1726         kgdb_io_ops = NULL;
1727
1728         spin_unlock(&kgdb_registration_lock);
1729
1730         printk(KERN_INFO
1731                 "kgdb: Unregistered I/O driver %s, debugger disabled.\n",
1732                 old_kgdb_io_ops->name);
1733 }
1734 EXPORT_SYMBOL_GPL(kgdb_unregister_io_module);
1735
1736 /**
1737  * kgdb_breakpoint - generate breakpoint exception
1738  *
1739  * This function will generate a breakpoint exception.  It is used at the
1740  * beginning of a program to sync up with a debugger and can be used
1741  * otherwise as a quick means to stop program execution and "break" into
1742  * the debugger.
1743  */
1744 void kgdb_breakpoint(void)
1745 {
1746         atomic_inc(&kgdb_setting_breakpoint);
1747         wmb(); /* Sync point before breakpoint */
1748         arch_kgdb_breakpoint();
1749         wmb(); /* Sync point after breakpoint */
1750         atomic_dec(&kgdb_setting_breakpoint);
1751 }
1752 EXPORT_SYMBOL_GPL(kgdb_breakpoint);
1753
1754 static int __init opt_kgdb_wait(char *str)
1755 {
1756         kgdb_break_asap = 1;
1757
1758         if (kgdb_io_module_registered)
1759                 kgdb_initial_breakpoint();
1760
1761         return 0;
1762 }
1763
1764 early_param("kgdbwait", opt_kgdb_wait);