kdb代码分析(五)

 

于是我们还是直接来看kdb()吧.这个函数有多长?说出来吓死你,近500行,光注释就有一两百行.写代码的估计一边写着,一边心里嘀咕着:XP不发威,你当我是DOS啊!

   1615 /*

   1616 * kdb

   1617 *

   1618 *      This function is the entry point for the kernel debugger. It

   1619 *      provides a command parser and associated support functions to

   1620 *      allow examination and control of an active kernel.

   1621 *

   1622 *      The breakpoint trap code should invoke this function with

   1623 *      one of KDB_REASON_BREAK (int 03) or KDB_REASON_DEBUG (debug register)

   1624 *

   1625 *      the die_if_kernel function should invoke this function with

   1626 *      KDB_REASON_OOPS.

   1627 *

   1628 *      In single step mode, one cpu is released to run without

   1629 *      breakpoints.   Interrupts and NMI are reset to their original values,

   1630 *      the cpu is allowed to do one instruction which causes a trap

   1631 *      into kdb with KDB_REASON_DEBUG.

   1632 *

   1633 * Inputs:

   1634 *      reason          The reason KDB was invoked

   1635 *      error           The hardware-defined error code

   1636 *      regs            The exception frame at time of fault/breakpoint. If reason

   1637 *                      is SILENT or CPU_UP then regs is NULL, otherwise it

   1638 *                      should always be valid.

   1639 * Returns:

   1640 *      0       KDB was invoked for an event which it wasn't responsible

   1641 *      1       KDB handled the event for which it was invoked.

   1642 * Locking:

   1643 *      none

   1644 * Remarks:

   1645 *     No assumptions of system state. This function may be invoked

   1646 *      with arbitrary locks held. It will stop all other processors

   1647 *      in an SMP environment, disable all interrupts and does not use

   1648 *      the operating systems keyboard driver.

   1649 *

   1650 *      This code is reentrant but only for cpu switch. Any other

   1651 *      reentrancy is an error, although kdb will attempt to recover.

   1652 *

   1653 *      At the start of a kdb session the initial processor is running

   1654 *      kdb() and the other processors can be doing anything. When the

   1655 *      initial processor calls smp_kdb_stop() the other processors are

   1656 *      driven through kdb_ipi which calls kdb() with reason SWITCH.

   1657 *      That brings all processors into this routine, one with a "real"

   1658 *      reason code, the other with SWITCH.

   1659 *

   1660 *      Because the other processors are driven via smp_kdb_stop(),

   1661 *      they enter here from the NMI handler. Until the other

   1662 *      processors exit from here and exit from kdb_ipi, they will not

   1663 *      take any more NMI requests. The initial cpu will still take NMI.

   1664 *

   1665 *      Multiple race and reentrancy conditions, each with different

   1666 *      advoidance mechanisms.

   1667 *

   1668 *      Two cpus hit debug points at the same time.

   1669 *

   1670 *        kdb_lock and kdb_initial_cpu ensure that only one cpu gets

   1671 *        control of kdb. The others spin on kdb_initial_cpu until

   1672 *        they are driven through NMI into kdb_ipi. When the initial

   1673 *        cpu releases the others from NMI, they resume trying to get

   1674 *        kdb_initial_cpu to start a new event.

   1675 *

   1676 *      A cpu is released from kdb and starts a new event before the

   1677 *      original event has completely ended.

   1678 *

   1679 *        kdb_previous_event() prevents any cpu from entering

   1680 *        kdb_initial_cpu state until the previous event has completely

   1681 *        ended on all cpus.

   1682 *

   1683 *      An exception occurs inside kdb.

   1684 *

   1685 *        kdb_initial_cpu detects recursive entry to kdb and attempts

   1686 *        to recover. The recovery uses longjmp() which means that

   1687 *        recursive calls to kdb never return. Beware of assumptions

   1688 *        like

   1689 *

   1690 *          ++depth;

   1691 *          kdb();

   1692 *          --depth;

   1693 *

   1694 *        If the kdb call is recursive then longjmp takes over and

   1695 *        --depth is never executed.

   1696 *

   1697 *      NMI handling.

   1698 *

   1699 *        NMI handling is tricky. The initial cpu is invoked by some kdb event,

   1700 *        this event could be NMI driven but usually is not. The other cpus are

   1701 *        driven into kdb() via kdb_ipi which uses NMI so at the start the other

   1702 *        cpus will not accept NMI. Some operations such as SS release one cpu

   1703 *        but hold all the others. Releasing a cpu means it drops back to

   1704 *        whatever it was doing before the kdb event, this means it drops out of

   1705 *        kdb_ipi and hence out of NMI status. But the software watchdog uses

   1706 *        NMI and we do not want spurious watchdog calls into kdb. kdba_read()

   1707 *        resets the watchdog counters in its input polling loop, when a kdb

   1708 *        command is running it is subject to NMI watchdog events.

   1709 *

   1710 *        Another problem with NMI handling is the NMI used to drive the other

   1711 *        cpus into kdb cannot be distinguished from the watchdog NMI. State

   1712 *        flag WAIT_IPI indicates that a cpu is waiting for NMI via kdb_ipi,

   1713 *        if not set then software NMI is ignored by kdb_ipi.

   1714 *

   1715 *      Cpu switching.

   1716 *

   1717 *        All cpus are in kdb (or they should be), all but one are

   1718 *        spinning on KDB_STATE(HOLD_CPU). Only one cpu is not in

   1719 *        HOLD_CPU state, only that cpu can handle commands.

   1720 *

   1721 *      Go command entered.

   1722 *

   1723 *        If necessary, go will switch to the initial cpu first. If the event

   1724 *        was caused by a software breakpoint (assumed to be global) that

   1725 *        requires single-step to get over the breakpoint then only release the

   1726 *        initial cpu, after the initial cpu has single-stepped the breakpoint

   1727 *        then release the rest of the cpus. If SSBPT is not required then

   1728 *        release all the cpus at once.

   1729 */

   1730

   1731 fastcall int

   1732 kdb(kdb_reason_t reason, int error, struct pt_regs *regs)

   1733 {

   1734         kdb_intstate_t int_state;       /* Interrupt state */

   1735         kdb_reason_t reason2 = reason;

   1736         int result = 0; /* Default is kdb did not handle it */

   1737         int ss_event, old_regs_saved = 0;

   1738         struct pt_regs *old_regs = NULL;

   1739         kdb_dbtrap_t db_result=KDB_DB_NOBPT;

   1740         preempt_disable();

   1741         atomic_inc(&kdb_event);

   1742

   1743         switch(reason) {

   1744         case KDB_REASON_OOPS:

   1745         case KDB_REASON_NMI:

   1746                 KDB_FLAG_SET(CATASTROPHIC);     /* kernel state is dubious now */

   1747                 break;

   1748         default:

   1749                 break;

   1750         }

   1751         switch(reason) {

   1752         case KDB_REASON_ENTER:

   1753         case KDB_REASON_ENTER_SLAVE:

   1754         case KDB_REASON_BREAK:

   1755         case KDB_REASON_DEBUG:

   1756         case KDB_REASON_OOPS:

   1757         case KDB_REASON_SWITCH:

   1758         case KDB_REASON_KEYBOARD:

   1759         case KDB_REASON_NMI:

   1760                 if (regs && regs != get_irq_regs()) {

   1761                         old_regs = set_irq_regs(regs);

   1762                         old_regs_saved = 1;

   1763                 }

  1764                 break;

   1765         default:

   1766                 break;

   1767         }

   1768         if (kdb_continue_catastrophic > 2) {

   1769                 kdb_printf("kdb_continue_catastrophic is out of range, setting to 2/n");

   1770                 kdb_continue_catastrophic = 2;

   1771         }

   1772         if (!kdb_on && KDB_FLAG(CATASTROPHIC) && kdb_continue_catastrophic == 2) {

   1773                 KDB_FLAG_SET(ONLY_DO_DUMP);

   1774         }

   1775         if (!kdb_on && !KDB_FLAG(ONLY_DO_DUMP))

   1776                 goto out;

   1777

   1778         KDB_DEBUG_STATE("kdb 1", reason);

   1779         KDB_STATE_CLEAR(SUPPRESS);

   1780

   1781         /* Filter out userspace breakpoints first, no point in doing all

  1782          * the kdb smp fiddling when it is really a gdb trap.

   1783          * Save the single step status first, kdba_db_trap clears ss status.

   1784          * kdba_b[dp]_trap sets SSBPT if required.

   1785          */

   1786         ss_event = KDB_STATE(DOING_SS) || KDB_STATE(SSBPT);

   1787 #ifdef CONFIG_CPU_XSCALE

   1788         if ( KDB_STATE(A_XSC_ICH) ) {

   1789                 /* restore changed I_BIT */

   1790                 KDB_STATE_CLEAR(A_XSC_ICH);

   1791                 kdba_restore_retirq(regs, KDB_STATE(A_XSC_IRQ));

   1792                 if ( !ss_event ) {

   1793                         kdb_printf("Stranger!!! Why IRQ bit is changed====/n");

   1794                 }

   1795         }

   1796 #endif

   1797         if (reason == KDB_REASON_BREAK) {

   1798                 db_result = kdba_bp_trap(regs, error); /* Only call this once */

   1799         }

   1800         if (reason == KDB_REASON_DEBUG) {

   1801                 db_result = kdba_db_trap(regs, error); /* Only call this once */

   1802         }

   1803

   1804         if ((reason == KDB_REASON_BREAK || reason == KDB_REASON_DEBUG)

   1805          && db_result == KDB_DB_NOBPT) {

   1806                 KDB_DEBUG_STATE("kdb 2", reason);

   1807                 goto out;       /* Not one of mine */

   1808         }

   1809

   1810         /* Turn off single step if it was being used */

   1811         if (ss_event) {

   1812                 kdba_clearsinglestep(regs);

   1813                 /* Single step after a breakpoint removes the need for a delayed reinstall */

   1814                 if (reason == KDB_REASON_BREAK || reason == KDB_REASON_DEBUG)

   1815                         KDB_STATE_CLEAR(SSBPT);

   1816         }

   1817

   1818         /* kdb can validly reenter but only for certain well defined conditions */

   1819         if (reason == KDB_REASON_DEBUG

   1820          && !KDB_STATE(HOLD_CPU)

   1821          && ss_event)

   1822                 KDB_STATE_SET(REENTRY);

   1823         else

   1824                 KDB_STATE_CLEAR(REENTRY);

   1825

   1826         /* Wait for previous kdb event to completely exit before starting

   1827          * a new event.

   1828          */

   1829         while (kdb_previous_event())

   1830                 ;

   1831         KDB_DEBUG_STATE("kdb 3", reason);

   1832

   1833         /*

   1834          * If kdb is already active, print a message and try to recover.

   1835          * If recovery is not possible and recursion is allowed or

   1836          * forced recursion without recovery is set then try to recurse

   1837          * in kdb. Not guaranteed to work but it makes an attempt at

   1838          * debugging the debugger.

   1839          */

   1840         if (reason != KDB_REASON_SWITCH &&

   1841             reason != KDB_REASON_ENTER_SLAVE) {

   1842                 if (KDB_IS_RUNNING() && !KDB_STATE(REENTRY)) {

   1843                         int recover = 1;

   1844                         unsigned long recurse = 0;

   1845                         kdb_printf("kdb: Debugger re-entered on cpu %d, new reason = %d/n",

   1846                                 smp_processor_id(), reason);

   1847                         /* Should only re-enter from released cpu */

   1848

   1849                         if (KDB_STATE(HOLD_CPU)) {

   1850                                 kdb_printf("     Strange, cpu %d should not be running/n", smp_processor_id());

   1851                                 recover = 0;

   1852                         }

   1853                         if (!KDB_STATE(CMD)) {

   1854                                 kdb_printf("     Not executing a kdb command/n");

   1855                                 recover = 0;

   1856                         }

   1857                         if (!KDB_STATE(LONGJMP)) {

   1858                                 kdb_printf("     No longjmp available for recovery/n");

   1859                                 recover = 0;

   1860                         }

   1861                         kdbgetulenv("RECURSE", &recurse);

   1862                         if (recurse > 1) {

   1863                                 kdb_printf("     Forced recursion is set/n");

   1864                                 recover = 0;

   1865                         }

   1866                         if (recover) {

   1867                                 kdb_printf("     Attempting to abort command and recover/n");

   1868 #ifdef kdba_setjmp

   1869                                 kdba_longjmp(&kdbjmpbuf[smp_processor_id()], 0);

   1870 #endif /* kdba_setjmp */

   1871                         }

   1872                         if (recurse) {

   1873                                 if (KDB_STATE(RECURSE)) {

   1874                                         kdb_printf("     Already in recursive mode/n");

   1875                                 } else {

   1876                                         kdb_printf("     Attempting recursive mode/n");

   1877                                         KDB_STATE_SET(RECURSE);

   1878                                         KDB_STATE_SET(REENTRY);

   1879                                         reason2 = KDB_REASON_RECURSE;

   1880                                         recover = 1;

   1881                                 }

   1882                         }

  1883                         if (!recover) {

   1884                                 kdb_printf("     Cannot recover, allowing event to proceed/n");

   1885                                 /*temp*/

   1886                                 while (KDB_IS_RUNNING())

   1887                                         cpu_relax();

   1888                                 goto out;

   1889                         }

   1890                 }

   1891         } else if (reason == KDB_REASON_SWITCH && !KDB_IS_RUNNING()) {

   1892                 kdb_printf("kdb: CPU switch without kdb running, I'm confused/n");

   1893                 goto out;

   1894         }

   1895

   1896         /*

   1897          * Disable interrupts, breakpoints etc. on this processor

   1898         * during kdb command processing

   1899          */

   1900         KDB_STATE_SET(KDB);

   1901         kdba_disableint(&int_state);

   1902         if (!KDB_STATE(KDB_CONTROL)) {

   1903                 kdb_bp_remove_local();

   1904                 KDB_STATE_SET(KDB_CONTROL);

   1905         }

   1906

   1907         /*

   1908          * If not entering the debugger due to CPU switch or single step

   1909          * reentry, serialize access here.

   1910          * The processors may race getting to this point - if,

   1911          * for example, more than one processor hits a breakpoint

   1912          * at the same time.   We'll serialize access to kdb here -

   1913          * other processors will loop here, and the NMI from the stop

   1914          * IPI will take them into kdb as switch candidates. Once

   1915          * the initial processor releases the debugger, the rest of

   1916          * the processors will race for it.

   1917          *

   1918          * The above describes the normal state of affairs, where two or more

   1919          * cpus that are entering kdb at the "same" time are assumed to be for

   1920          * separate events. However some processes such as ia64 MCA/INIT will

   1921          * drive all the cpus into error processing at the same time. For that

   1922          * case, all of the cpus entering kdb at the "same" time are really a

   1923          * single event.

   1924          *

   1925          * That case is handled by the use of KDB_ENTER by one cpu (the

   1926          * monarch) and KDB_ENTER_SLAVE on the other cpus (the slaves).

   1927          * KDB_ENTER_SLAVE maps to KDB_REASON_ENTER_SLAVE. The slave events

   1928          * will be treated as if they had just responded to the kdb IPI, i.e.

   1929          * as if they were KDB_REASON_SWITCH.

   1930          *

   1931          * Because of races across multiple cpus, ENTER_SLAVE can occur before

   1932          * the main ENTER.   Hold up ENTER_SLAVE here until the main ENTER

   1933          * arrives.

   1934          */

   1935

   1936         if (reason == KDB_REASON_ENTER_SLAVE) {

   1937                 spin_lock(&kdb_lock);

   1938                 while (!KDB_IS_RUNNING()) {

   1939                         spin_unlock(&kdb_lock);

   1940                         while (!KDB_IS_RUNNING())

   1941                                 cpu_relax();

   1942                         spin_lock(&kdb_lock);

   1943                 }

   1944                 reason = KDB_REASON_SWITCH;

   1945                 KDB_STATE_SET(HOLD_CPU);

   1946                 spin_unlock(&kdb_lock);

   1947         }

   1948

   1949         if (reason == KDB_REASON_SWITCH || KDB_STATE(REENTRY))

   1950                 ;       /* drop through */

   1951         else {

   1952                 KDB_DEBUG_STATE("kdb 4", reason);

   1953                 spin_lock(&kdb_lock);

   1954                 while (KDB_IS_RUNNING() || kdb_previous_event()) {

   1955                         spin_unlock(&kdb_lock);

   1956                         while (KDB_IS_RUNNING() || kdb_previous_event())

   1957                                 cpu_relax();

   1958                         spin_lock(&kdb_lock);

   1959                 }

   1960                 KDB_DEBUG_STATE("kdb 5", reason);

   1961

   1962                 kdb_initial_cpu = smp_processor_id();

   1963                 ++kdb_seqno;

   1964                 spin_unlock(&kdb_lock);

   1965                 if (!kdb_quiet(reason))

   1966                         notify_die(DIE_KDEBUG_ENTER, "KDEBUG ENTER", regs, error, 0, 0);

   1967         }

   1968

   1969         if (smp_processor_id() == kdb_initial_cpu

   1970          && !KDB_STATE(REENTRY)) {

   1971                 KDB_STATE_CLEAR(HOLD_CPU);

   1972                 KDB_STATE_CLEAR(WAIT_IPI);

   1973                 kdb_check_i8042();

   1974                 /*

   1975                  * Remove the global breakpoints. This is only done

   1976                  * once from the initial processor on initial entry.

   1977                  */

   1978                 if (!kdb_quiet(reason) || smp_processor_id() == 0)

   1979                         kdb_bp_remove_global();

   1980

   1981                 /*

   1982                  * If SMP, stop other processors. The other processors

   1983                  * will enter kdb() with KDB_REASON_SWITCH and spin in

   1984                  * kdb_main_loop().

   1985                  */

   1986                 KDB_DEBUG_STATE("kdb 6", reason);

   1987                 if (NR_CPUS > 1 && !kdb_quiet(reason)) {

   1988                         int i;

   1989                         for (i = 0; i < NR_CPUS; ++i) {

   1990                                 if (!cpu_online(i))

   1991                                         continue;

   1992                                 if (i != kdb_initial_cpu) {

   1993                                     KDB_STATE_SET_CPU(HOLD_CPU, i);

   1994                                      KDB_STATE_SET_CPU(WAIT_IPI, i);

   1995                                 }

   1996                         }

   1997                         KDB_DEBUG_STATE("kdb 7", reason);

   1998                         smp_kdb_stop();

   1999                         KDB_DEBUG_STATE("kdb 8", reason);

   2000                 }

   2001         }

   2002

   2003         if (KDB_STATE(GO1)) {

   2004                 kdb_bp_remove_global();         /* They were set for single-step purposes */

   2005                 KDB_STATE_CLEAR(GO1);

   2006                 reason = KDB_REASON_SILENT;     /* Now silently go */

   2007         }

   2008

   2009         /* Set up a consistent set of process stacks before talking to the user */

   2010         KDB_DEBUG_STATE("kdb 9", result);

   2011         result = kdba_main_loop(reason, reason2, error, db_result, regs);

   2012

   2013         KDB_DEBUG_STATE("kdb 10", result);

   2014         kdba_adjust_ip(reason2, error, regs);

   2015         KDB_STATE_CLEAR(LONGJMP);

   2016         KDB_DEBUG_STATE("kdb 11", result);

   2017         /* go which requires single-step over a breakpoint must only release

   2018          * one cpu.

   2019          */

   2020         if (result == KDB_CMD_GO && KDB_STATE(SSBPT))

   2021                 KDB_STATE_SET(GO1);

   2022

   2023         if (smp_processor_id() == kdb_initial_cpu &&

   2024           !KDB_STATE(DOING_SS) &&

   2025           !KDB_STATE(RECURSE)) {

   2026                 /*

   2027                  * (Re)install the global breakpoints and cleanup the cached

   2028                  * symbol table. This is only done once from the initial

   2029                  * processor on go.

   2030                  */

   2031                 KDB_DEBUG_STATE("kdb 12", reason);

   2032                 if (!kdb_quiet(reason) || smp_processor_id() == 0) {

   2033                         kdb_bp_install_global(regs);

   2034                         kdbnearsym_cleanup();

   2035                         debug_kusage();

   2036                 }

   2037                 if (!KDB_STATE(GO1)) {

   2038                         /*

   2039                          * Release all other cpus which will see KDB_STATE(LEAVING) is set.

   2040                          */

   2041                         int i;

   2042                         for (i = 0; i < NR_CPUS; ++i) {

   2043                                 if (KDB_STATE_CPU(KDB, i))

   2044                                       KDB_STATE_SET_CPU(LEAVING, i);

   2045                                 KDB_STATE_CLEAR_CPU(WAIT_IPI, i);

   2046                                 KDB_STATE_CLEAR_CPU(HOLD_CPU, i);

   2047                         }

   2048                         /* Wait until all the other processors leave kdb */

   2049                         while (kdb_previous_event() != 1)

   2050                                 ;

   2051                         if (!kdb_quiet(reason))

   2052                                 notify_die(DIE_KDEBUG_LEAVE, "KDEBUG LEAVE", regs, error, 0, 0);

   2053                         kdb_initial_cpu = -1;   /* release kdb control */

   2054                         KDB_DEBUG_STATE("kdb 13", reason);

   2055                 }

   2056         }

   2057

   2058         KDB_DEBUG_STATE("kdb 14", result);

   2059         kdba_restoreint(&int_state);

   2060 #ifdef CONFIG_CPU_XSCALE

   2061         if ( smp_processor_id() == kdb_initial_cpu &&

   2062              ( KDB_STATE(SSBPT) | KDB_STATE(DOING_SS) )

   2063               ) {

   2064                 kdba_setsinglestep(regs);

   2065                 // disable IRQ in stack frame

   2066                 KDB_STATE_SET(A_XSC_ICH);

   2067                 if ( kdba_disable_retirq(regs) ) {

   2068                         KDB_STATE_SET(A_XSC_IRQ);

   2069                 }

   2070                 else {

   2071                         KDB_STATE_CLEAR(A_XSC_IRQ);

   2072                }

   2073         }

   2074 #endif

   2075

   2076         /* Only do this work if we are really leaving kdb */

   2077         if (!(KDB_STATE(DOING_SS) || KDB_STATE(SSBPT) || KDB_STATE(RECURSE))) {

   2078                 KDB_DEBUG_STATE("kdb 15", result);

   2079                 kdb_bp_install_local(regs);

   2080                 if (old_regs_saved)

   2081                         set_irq_regs(old_regs);

   2082                 KDB_STATE_CLEAR(KDB_CONTROL);

   2083         }

   2084

   2085         KDB_DEBUG_STATE("kdb 16", result);

   2086         KDB_FLAG_CLEAR(CATASTROPHIC);

   2087         KDB_STATE_CLEAR(IP_ADJUSTED);   /* Re-adjust ip next time in */

   2088         KDB_STATE_CLEAR(KEYBOARD);

   2089         KDB_STATE_CLEAR(KDB);           /* Main kdb state has been cleared */

   2090         KDB_STATE_CLEAR(RECURSE);

   2091         KDB_STATE_CLEAR(LEAVING);       /* No more kdb work after this */

   2092         KDB_DEBUG_STATE("kdb 17", reason);

   2093 out:

   2094         atomic_dec(&kdb_event);

   2095         preempt_enable();

   2096         return result != 0;

   2097 }

星爷说:”做人要是没有理想,那和咸鱼有什么区别呀?”而我现在的理想就是希望能够看懂这个变态的函数.老实说,面对这么一个庞然大物,要完全看明白的确有难度,我只能郭天王的话来鼓励一下自己了:”因为难,才好玩,结果,重要吗?”

在我们前面调用kdb()的时候,我们传递的第一个参数,reason,有两种情况,一种是我们传递的是KDB_REASON_KEYBOARD,一种是KDB_REASON_ENTER,因此我们就分别来看看这两种情形:

对于KDB_REASON_KEYBOARD:

你会发现,虽然kdb()看起来很复杂,但其实你真正需要关注的代码并不多,很多代码实际上在普通情况下不会执行,另外很多代码只是用于调试,尤其是你第一次进入kdb,你首先要关注的代码就是1998行这个smp_kdb_stop().这个函数也是体系结构相关的,对于i386,其定义在arch/i386/kdb/kdbasupport.c:

   1028 /* When first entering KDB, try a normal IPI. That reduces backtrace problems

   1029 * on the other cpus.

   1030 */

   1031 void

   1032 smp_kdb_stop(void)

   1033 {

   1034         if (!KDB_FLAG(NOIPI))

   1035                 send_IPI_allbutself(KDB_VECTOR);

   1036 }

虽然这个函数的名字已经隐隐约约告诉我们,其作用就是停止其它的处理器.但我们还是有必要仔细看一看.这里涉及到IPI,IPI是处理器间中断(interprocessor interrupt),这是smp中很重要的一个概念.而send_IPI_allbutself(int vector)就是发送IPI给除自己以外的所有CPU,这个参数vector表示中断类型.而之前我们其实也看到过KDB_VECTOR.我们在arch/i386/kernel/entry.S中要加入下面这段:

   8942 +#ifdef CONFIG_SMP

   8943 +BUILD_INTERRUPT(kdb_interrupt,KDB_VECTOR)

   8944 +#endif /* CONFIG_SMP */

而BUILD_INTERRUPT实际上是kernel中本来就有的宏,它也定义于arch/i386/kernel/entry.S中:

    624 #define BUILD_INTERRUPT(name, nr)       /

    625 ENTRY(name)                             /

    626         RING0_INT_FRAME;                /

    627         pushl $~(nr);                   /

    628         CFI_ADJUST_CFA_OFFSET 4;        /

    629         SAVE_ALL;                       /

    630         TRACE_IRQS_OFF                  /

    631         movl %esp,%eax;                 /

    632         call smp_##name;                /

    633         jmp ret_from_intr;              /

    634         CFI_ENDPROC;                    /

    635 ENDPROC(name)

很明显,这又是一个中断句柄,并且真正的中断服务函数就是smp_kdb_interrupt().这个函数是我们自己定义的,对于i386,它的定义在arch/i386/kdb/kdbasupport.c:

   1038 /* The normal KDB IPI handler */

   1039 void

   1040 smp_kdb_interrupt(struct pt_regs *regs)

   1041 {

   1042         struct pt_regs *old_regs = set_irq_regs(regs);

   1043         ack_APIC_irq();

   1044         irq_enter();

   1045         kdb_ipi(regs, NULL);

   1046         irq_exit();

   1047         set_irq_regs(old_regs);

   1048 }

写代码和我们与人交往是一样的,有很多东西都是虚的.我们常说,废话是人际关系的第一句话,写代码也是如此,为了调用一个关键的函数,首先它会调用一些看起来没什么意义的函数,就比如这个smp_kdb_interrupt(),它最终的目的就是调用kdb_ipi(),可在这之前它调用了set_irq_regs(),ack_APIC_irq(),irq_enter()等函数,当然你如果真的理解这段代码的话,你确实可以说这些函数调用都是很有必要的,不过从看代码的角度来说,你可以不必care这几个函数,直接切入重点,直面kdb_ipi().这个函数来自于我们的common patch,它被添加到了kdb/kdbsupport.c中:

    252 #if defined(CONFIG_SMP)

    253 /*

    254 * kdb_ipi

    255 *

    256 *      This function is called from the non-maskable interrupt

    257 *      handler to handle a kdb IPI instruction.

    258 *

    259 * Inputs:

    260 *      regs    = Exception frame pointer

    261 * Outputs:

    262 *      None.

    263 * Returns:

    264 *      0       - Did not handle NMI

    265 *      1       - Handled NMI

    266 * Locking:

    267 *      None.

    268 * Remarks:

    269 *      Initially one processor is invoked in the kdb() code. That

    270 *      processor sends an ipi which drives this routine on the other

    271 *      processors. All this does is call kdb() with reason SWITCH.

    272 *      This puts all processors into the kdb() routine and all the

    273 *      code for breakpoints etc. is in one place.

    274 *      One problem with the way the kdb NMI is sent, the NMI has no

    275 *      identification that says it came from kdb. If the cpu's kdb state is

    276 *      marked as "waiting for kdb_ipi" then the NMI is treated as coming from

    277 *      kdb, otherwise it is assumed to be for another reason and is ignored.

    278 */

    279

    280 int

    281 kdb_ipi(struct pt_regs *regs, void (*ack_interrupt)(void))

    282 {

    283         /* Do not print before checking and clearing WAIT_IPI, IPIs are

    284          * going all the time.

    285          */

    286         if (KDB_STATE(WAIT_IPI)) {

    287                 /*

    288                  * Stopping other processors via smp_kdb_stop().

    289                  */

    290                 if (ack_interrupt)

    291                         (*ack_interrupt)();     /* Acknowledge the interrupt */

    292                 KDB_STATE_CLEAR(WAIT_IPI);

    293                 KDB_DEBUG_STATE("kdb_ipi 1", 0);

    294                 kdb(KDB_REASON_SWITCH, 0, regs);        /* Spin in kdb() */

    295                 KDB_DEBUG_STATE("kdb_ipi 2", 0);

    296                 return 1;

    297         }

    298         return 0;

    299 }

    300 #endif /* CONFIG_SMP */

注意到刚才调用kdb_ipi()的时候,第二个参数是NULL,所以这里的ack_interrupt是NULL,换言之,291行不会被执行.于是乎,真正要执行的也就只是294行这个kdb(),记住它的第一个参数是KDB_REASON_SWITCH.这很有趣,等于说各个处理器都要在同一时刻执行kdb(),但是它们虽然执行同一个函数,意义却截然不同,原因是它们的参数一个是KDB_REASON_SWITCH,另一个则是KDB_REASON_KEYBOARD.这种情形在生活中也很普遍,它就相当于不同的人,虽然做同一件事情,但是意义却不同,比如,对于色狼来说,脱光了就开始”娱乐”;对于艺术家来说,脱光了就开始”艺术”.