kgdb源代码分析(2.6.27)第二章－准备工作

(kernel/kgdb.c)
1392 int
1393 kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs
*regs)
1394 {
1395        struct kgdb_state kgdb_var;
1396        struct kgdb_state *ks = &kgdb_var;
1397        unsigned long flags;
1398        int error = 0;
1399        int i, cpu;
1400
1401        ks->cpu                     = raw_smp_processor_id();
1402        ks->ex_vector               = evector;
1403        ks->signo                   = signo;
1404        ks->ex_vector               = evector;
1405        ks->err_code                = ecode;
1406        ks->kgdb_usethreadid         = 0;
1407        ks->linux_regs             = regs;
1408
1409        if (kgdb_reenter_check(ks))
1410                  return 0; /* Ouch, double exception ! */

(kernel/kgdb.c)
1412 acquirelock:
1413          /*
1414              * Interrupts will be restored by the 'trap return' code, except
when
1415           * single stepping.
1416           */
1417          local_irq_save(flags);
1418
1419          cpu = raw_smp_processor_id();
1420
1421          /*
1422           * Acquire the kgdb_active lock:
1423           */
1424 while (atomic_cmpxchg(&kgdb_active, -1, cpu) != -1)
1425          cpu_relax();

(kernel/kgdb.c)
1427          /*
1428            * Do not start the debugger connection on this CPU if the last
1429            * instance of the exception handler wanted to come into the
1430            * debugger on a different CPU via a single step
1431            */
1432          if (atomic_read(&kgdb_cpu_doing_single_step) != -1 &&
1433                atomic_read(&kgdb_cpu_doing_single_step) != cpu) {
1434
1435                    atomic_set(&kgdb_active, -1);
1436                    touch_softlockup_watchdog();
1437                    clocksource_touch_watchdog();
1438                    local_irq_restore(flags);
1439
1440                    goto acquirelock;
1441          }

(kernel/kgdb.c)
1443          if (!kgdb_io_ready(1)) {
1444                   error = 1;
1445                     goto kgdb_restore; /* No I/O connection, so resume the
system */
1446          }

(kernel/kgdb.c)
1448          /*
1449            * Don't enter if we have hit a removed breakpoint.
1450            */
1451          if (kgdb_skipexception(ks->ex_vector, ks->linux_regs))
1452                   goto kgdb_restore;

(arch/x86/kernel/kgdb.c)
530 /**
531 *
532 *       kgdb_skipexception - Bail out of KGDB when we've been triggered.
533 *       @exception: Exception vector number
534 *       @regs: Current &struct pt_regs.
535 *
536 *           On some architectures we need to skip a breakpoint exception
when
537 *       it occurs after a breakpoint has been removed.
538 *
539 * Skip an int3 exception when it occurs after a breakpoint has been
540 * removed. Backtrack eip by 1 since the int3 would have caused it to
541 * increment by 1.
542 */
543 int kgdb_skipexception(int exception, struct pt_regs *regs)
544 {
545         if (exception == 3 && kgdb_isremovedbreak(regs->ip - 1)) {
546                  regs->ip -= 1;
547                  return 1;
548         }
549         return 0;
550 }

We keep track of removed entries to prevent breakpoints from occuring after
they were removed. Removed breakpoints might have occured on other processors
before there removal from code, which will pop up on continuing and cause
segfaults on i386. kgdb_skipexception function identifies them.

(kernel/kgdb.c)
1458          kgdb_info[ks->cpu].debuggerinfo = ks->linux_regs;
1459          kgdb_info[ks->cpu].task = current;
1460
1461          kgdb_disable_hw_debug(ks->linux_regs);

(drivers/serial/kgdboc.c)
143 static void kgdboc_pre_exp_handler(void)
144 {
145   /* Increment the module count when the debugger is active */
146   if (!kgdb_connected)
147            try_module_get(THIS_MODULE);
148 }

(arch/x86/kernel/kgdb.c)
300 /**
301 *       kgdb_disable_hw_debug - Disable hardware debugging while we in
kgdb.
302 *       @regs: Current &struct pt_regs.
303 *
304 *       This function will be called if the particular architecture must
305 *       disable hardware debugging while it is processing gdb packets or
306 *       handling exception.
307 */
308 void kgdb_disable_hw_debug(struct pt_regs *regs)
309 {
310         /* Disable hardware debugging while we are in kgdb: */
311         set_debugreg(0UL, 7);
312 }

(kernel/kgdb.c)
1463          /*
1464            * Get the passive CPU lock which will hold all the non-primary
1465            * CPU in a spin state while the debugger is active
1466            */
1467          if (!kgdb_single_step) {
1468                    for (i = 0; i < NR_CPUS; i++)
1469                             atomic_set(&passive_cpu_wait[i], 1);
1470          }

(kernel/kgdb.c)
1472          /*
1473            * spin_lock code is good enough as a barrier so we don't
1474            * need one here:
1475            */
1476          atomic_set(&cpu_in_kgdb[ks->cpu], 1);
1477
1478 #ifdef CONFIG_SMP
1479          /* Signal the other CPUs to enter kgdb_wait() */
1480          if ((!kgdb_single_step) && kgdb_do_roundup)
1481                    kgdb_roundup_cpus(flags);
1482 #endif
1483
1484          /*
1485            * Wait for the other CPUs to be notified and be waiting for us:
1486            */
1487          for_each_online_cpu(i) {
1488                    while (!atomic_read(&cpu_in_kgdb[i]))
1489                             cpu_relax();
1490          }

(arch/x86/kernel/kgdb.c)
348 void kgdb_roundup_cpus(unsigned long flags)
349 {
350         send_IPI_allbutself(APIC_DM_NMI);
351 }

(arch/x86/kernel/kgdb.c)
442 static int __kgdb_notify(struct die_args *args, unsigned long cmd)
443 {
444           struct pt_regs *regs = args->regs;
445
446           switch (cmd) {
447           case DIE_NMI:
448                    if (atomic_read(&kgdb_active) != -1) {
449                             /* KGDB CPU roundup */
450                             kgdb_nmicallback(raw_smp_processor_id(), regs);
451                             was_in_debug_nmi[raw_smp_processor_id()] = 1;
452                             touch_nmi_watchdog();
453                             return NOTIFY_STOP;
454                    }
455                    return NOTIFY_DONE;
456
457           case DIE_NMI_IPI:
458                    /* Just ignore, we will handle the roundup on DIE_NMI. */
459                    return NOTIFY_DONE;

(kernel/kgdb.c)
1536 int kgdb_nmicallback(int cpu, void *regs)
1537 {
1538 #ifdef CONFIG_SMP
1539          if (!atomic_read(&cpu_in_kgdb[cpu]) &&
1540                           atomic_read(&kgdb_active) != cpu &&
1541
atomic_read(&cpu_in_kgdb[atomic_read(&kgdb_active)])) {
1542                   kgdb_wait((struct pt_regs *)regs);
1543                   return 0;
1544          }
1545 #endif
1546          return 1;
1547 }

(kernel/kgdb.c)
 564 static void kgdb_wait(struct pt_regs *regs)
 565 {
 566          unsigned long flags;
 567          int cpu;
 568
 569          local_irq_save(flags);
 570          cpu = raw_smp_processor_id();
 571          kgdb_info[cpu].debuggerinfo = regs;
 572          kgdb_info[cpu].task = current;
 573          /*
 574            * Make sure the above info reaches the primary CPU before
 575            * our cpu_in_kgdb[] flag setting does:
 576            */
 577          smp_wmb();
 578          atomic_set(&cpu_in_kgdb[cpu], 1);
 579
 580          /* Wait till primary CPU is done with debugging */
 581          while (atomic_read(&passive_cpu_wait[cpu]))
 582                   cpu_relax();
 583
 584          kgdb_info[cpu].debuggerinfo = NULL;
 585          kgdb_info[cpu].task = NULL;
 586
 587          /* fix up hardware debug registers on local cpu */
 588          if (arch_kgdb_ops.correct_hw_break)
 589                   arch_kgdb_ops.correct_hw_break();
 590
 591          /* Signal the primary CPU that we are done: */
 592          atomic_set(&cpu_in_kgdb[cpu], 0);
 593          touch_softlockup_watchdog();
 594          clocksource_touch_watchdog();
 595          local_irq_restore(flags);
 596 }

(kernel/kgdb.c)
1513          if (!kgdb_single_step) {
1514                   for (i = NR_CPUS-1; i >= 0; i--)
1515                             atomic_set(&passive_cpu_wait[i], 0);
1516                   /*
1517                     * Wait till all the CPUs have quit
1518                     * from the debugger.
1519                     */
1520                   for_each_online_cpu(i) {
1521                             while (atomic_read(&cpu_in_kgdb[i]))
1522                                       cpu_relax();
1523                   }
1524          }

(kernel/kgdb.c)
1492          /*
1493           * At this point the primary processor is completely
1494           * in the debugger and all secondary CPUs are quiescent
1495           */
1496               kgdb_post_primary_code(ks->linux_regs, ks->ex_vector, ks-
>err_code);
1497          kgdb_deactivate_sw_breakpoints();
1498          kgdb_single_step = 0;
1499          kgdb_contthread = current;
1500          exception_level = 0;

(kernel/kgdb.c)
1502          /* Talk to debugger with gdbserial protocol */
1503          error = gdb_serial_stub(ks);