揭开Linux系统内核调试器的神秘面纱

天下无乱

版主

Rank: 7 Rank: 7 Rank: 7

1^# 大中小发表于 2007-7-7 00:38 只看该作者

揭开Linux系统内核调试器的神秘面纱

KDB 入门指南

调试内核问题时，能够跟踪内核执行情况并查看其内存和数据结构是非常有用的。Linux 中的内置内核调试器 KDB 提供了这种功能。在本文中您把了解怎么样使用 KDB 所提供的功能，以及怎么样在 Linux 机器上安装和设置 KDB。您还把熟悉 KDB 中可以使用的命令以及设置和显示选项。 * }" D# E0 G; a3 B( c& W2 d0 i; M8 Z

Linux 内核调试器（KDB）允许您调试 Linux 内核。这个恰如其名的工具实质上是内核代码的补丁，它允许高手访问内核内存和数据结构。KDB 的主要优点之一就是它不需要用另一台机器进行调试：您可以调试正在运行的内核。 5 T6 D, y2 G, ^' t' Q

设置一台用于 KDB 的机器需要花费一些工作，因为需要给内核打补丁并进行重新编译。KDB 的用户应当熟悉 Linux 内核的编译（在一定程度上还要熟悉内核内部机理），但是如果您需要编译内核方面的帮助，请参阅本文结尾处的参考资料一节。 6 R, U( o, v1 d2 c

在本文中，我们把从有关下载 KDB 补丁、打补丁、（重新）编译内核以及启动 KDB 方面的信息着手。然后我们把了解 KDB 命令并研究一些较常用的命令。最后，我们把研究一下有关设置和显示选项方面的一些详细信息。
4 P) J9 P* B/ M0 g# T8 j
入门
4 b" u: F) d. V4 ]0 I3 r
KDB 项目是由 Silicon Graphics 维护的（请参阅参考资料以获取链接），您需要从它的 FTP 站点下载与内核版本有关的补丁。（在编写本文时）可用的最新 KDB 版本是 4.2。您把需要下载并应用两个补丁。

一个是“公共的”补丁，包含了对通用内核代码的更改，另一个是特定于体系结构的补丁。补丁可作为 bz2 文件获取。例如，在运行 2.4.20 内核的 x86 机器上，您会需要 kdb-v4.2-2.4.20-common-1.bz2 和 kdb-v4.2-2.4.20-i386-1.bz2。
8 ^- F0 h* g1 v
这里所提供的所有示例都是针对 i386 体系结构和 2.4.20 内核的。您把需要根据您的机器和内核版本进行适当的更改。您还需要拥有 root 许可权以执行这些操作。 . y* V5 J& N7 R- L" u; d

把文件复制到 /usr/src/linux 目录中并从用 bzip2 压缩的文件解压缩补丁文件： " @1 d3 G6 X. K  \# ?1 w1 H
( S, m2 T5 g2 r2 m- o# P6 j
#bzip2 -d kdb-v4.2-2.4.20-common-1.bz2 + y  K2 B2 R6 a

#bzip2 -d kdb-v4.2-2.4.20-i386-1.bz2

您把获得 kdb-v4.2-2.4.20-common-1 和 kdb-v4.2-2.4-i386-1 文件。
0 `2 i& @% L' [. P5 B
现在，应用这些补丁：
9 {5 a, {7 o; Z" X: i
#patch -p1 ( N1 z: n, e: \3 j$ Z5 G2 J
#patch -p1
这些补丁应该干净利落地加以应用。查找任何以 .rej 结尾的文件。这个扩展名表明这些是失败的补丁。如果内核树没问题，那么补丁的应用就不会有任何问题。 2 V0 Y( [1 o% Y. S, R, Z3 y

接下来，需要构建内核以支持 KDB。第一步是设置 CONFIG_KDB 选项。使用您喜欢的配置机制（xconfig 和 menuconfig 等）来完成这一步。转到结尾处的“Kernel hacking”部分并选择“Built-in Kernel Debugger support”选项。

您还可以根据自己的偏好选择其它两个选项。选择“Compile the kernel with frame pointers”选项（如果有的话）则设置 CONFIG_FRAME_POINTER 标志。这把产生更好的堆栈回溯，因为帧指针寄存器被用作帧指针而不是通用寄存器。

您还可以选择“KDB off by default”选项。这把设置 CONFIG_KDB_OFF 标志，并且在缺省情况下把关闭 KDB。我们把在后面一节中对此进行详细介绍。 . N: h+ U$ L. |6 g

保存配置，然后退出。重新编译内核。建议在构建内核之前执行“make clean”。用常用方式安装内核并引导它。
" G8 _1 |. P* c" _6 k7 `
初始化并设置环境变量   m  [) ?! J6 X

您可以定义把在 KDB 初始化期间执行的 KDB 命令。需要在纯文本文件 kdb_cmds 中定义这些命令，该文件位于 Linux 源代码树（当然是在打了补丁之后）的 KDB 目录中。该文件还可以用来定义设置显示和打印选项的环境变量。文件开头的注释提供了编辑文件方面的帮助。使用这个文件的缺点是，在您更改了文件之后需要重新构建并重新安装内核。   K7 K- C) N# k# E/ T% g8 p
' e! X& X$ }* s
激活 KDB 7 C9 D# k9 H6 z2 n  S' A0 J
1 D) H, Y: O% p( H+ I& p- _
如果编译期间没有选中 CONFIG_KDB_OFF，那么在缺省情况下 KDB 是活动的。否则，您需要显式地激活它－通过在引导期间把 kdb=on 标志传递给内核或者通过在挂装了 /proc 之后执行该工作：
& @' ]( G0 v/ X/ T& J
#echo "1" ＞/proc/sys/kernel/kdb

倒过来执行上述步骤则会取消激活 KDB。也就是说，如果缺省情况下 KDB 是打开的，那么把 kdb=off 标志传递给内核或者执行下面这个操作把会取消激活 KDB： : K# Q0 l" D# X6 r

#echo "0" ＞/proc/sys/kernel/kdb ! g2 H. m5 G! F! e& Q$ b5 C* v% i
我们可以看到 rmqueue() 被 __alloc_pages 调用，后者接下来又被 _alloc_pages 调用，以此类推。 9 \5 T+ \: P& Z
每一帧的第一个双字（double word）指向下一帧，这后面紧跟着调用函数的地址。因此，跟踪堆栈就变成一件轻松的工作了。

go 命令可以有选择地以一个地址作为参数。如果您想在某个特定地址处继续执行，则可以提供该地址作为参数。另一个办法是使用 rm 命令修改指令指针寄存器，然后只要输入 go。如果您想跳过似乎会引起问题的某个特定指令或一组指令，这就会很有用。但是，请注意，该指令使用不慎会造成严重的问题，系统可能会严重崩溃。

您可以利用一个名为 defcmd 的有用命令来定义自己的命令集。例如，每当遇到断点时，您可能希望能同时检查某个特殊变量、检查某些寄存器的内容并转储堆栈。通常，您必须要输入一系列命令，以便能同时执行所有这些工作。defcmd 允许您定义自己的命令，该命令可以包含一个或多个预定义的 KDB 命令。然后只需要用一个命令就可以完成所有这三项工作。其语法如下：
[0]kdb> defcmd name "usage" "help" 6 J0 d% p1 }7 m  {
) x) u/ _7 L5 H8 y- u+ k1 h( u+ G
[0]kdb> [defcmd] type the commands here
8 V* w8 F) f- {; \5 O8 }3 x
[0]kdb> [defcmd] endefcmd
例如，可以定义一个（简单的）新命令 hari，它显示从地址 0xc000000 开始的一行内存、显示寄存器的内容并转储堆栈： ( W9 V" e2 X8 L* c5 s
[0]kdb> defcmd hari "" "no arguments needed"

[0]kdb> [defcmd] md 0xc000000 1 / p; |/ y/ s! M* V7 E3 T; D+ e6 x
6 O" N; X6 [4 |3 Q
[0]kdb> [defcmd] rd $ n5 M2 l( V- c: \! `
8 F1 g( s  a% q8 j, ?% M# k# L, i
[0]kdb> [defcmd] md 雙 1 ( H+ q' |+ X7 j' T4 M0 j) X8 \

[0]kdb> [defcmd] endefcmd" m1 [6 A; S8 o1 i4 h4 q4 d. i
该命令的输出会是：
[0]kdb> hari
2 `0 N: ]" I" R* T- c1 v% y) \
[hari]kdb> md 0xc000000 1 5 O$ U6 z1 t; }8 C; L) l

0xc000000 00000001 f000e816 f000e2c3 f000e816

[hari]kdb> rd 8 T" q# n' {) n  U2 t5 b* Q& B- P
3 ]# L1 ~2 J+ g8 ?
eax = 0x00000000 ebx = 0xc0105330 ecx = 0xc0466000 edx = 0xc0466000 : U7 \1 p) S: Y0 u- Z8 V
....
...
: Z" M  n& r- O, `' ~
[hari]kdb> md 雙 1

0xc0467fbc c0467fd0 c01053d2 00000002 000a0200

[0]kdb>

可以使用 bph 和 bpha 命令（假如体系结构支持使用硬件寄存器）来应用读写断点。这意味着每当从某个特定地址读取数据或将数据写入该地址时，我们都可以对此进行控制。当调试数据／内存毁坏问题时这可能会极其方便，在这种情况中您可以用它来识别毁坏的代码／进程。 ; N4 w  d% D. [! p$ j6 ^8 g  n
示例 ( B1 D4 m0 `5 d+ |1 |
每当将四个字节写入地址 0xc0204060 时就进入内核调试器： / F4 Q9 b& I6 ?; l) Z
[0]kdb> bph 0xc0204060 dataw 4 4 `- u, d( H" I3 y( w+ |' m* C
在读取从 0xc000000 开始的至少两个字节的数据时进入内核调试器：
[0]kdb> bph 0xc000000 datar 26 p6 ~& \2 Y4 x3 f! W* {
结束语4 `4 O/ Y" X( P: D

对于执行内核调试，KDB 是一个方便的且功能强大的工具。它提供了各种选项，并且使我们能够分析内存内容和数据结构。最妙的是，它不需要用另一台机器来执行调试。 * X8 E7 Y5 z. k# \' P1 _+ S
C 语言作为 Linux 系统上标准的编程语言给予了我们对动态内存分配很大的控制权。然而，这种自由可能会导致严重的内存管理问题，而这些问题可能导致程序崩溃或随时间的推移导致性能降级。 $ Z/ S, |! R' |+ j: ?( k
6 @; M  g; y+ [
内存泄漏（即 malloc() 内存在对应的 free() 调用执行后永不被释放）和缓冲区溢出（例如对以前分配到某数组的内存进行写操作）是一些常见的问题，它们可能很难检测到。这一部分将讨论几个调试工具，它们极大地简化了检测和找出内存问题的过程。

MEMWATCH 由 Johan Lindh 编写，是一个开放源代码 C 语言内存错误检测工具，您可以自己下载它（请参阅本文后面部分的参考资料）。只要在代码中添加一个头文件并在 gcc 语句中定义了 MEMWATCH 之后，您就可以跟踪程序中的内存泄漏和错误了。MEMWATCH 支持 ANSI C，它提供结果日志纪录，能检测双重释放（double-free）、错误释放（erroneous free）、没有释放的内存（unfreed memory）、溢出和下溢等等。 , H7 a  Y0 A# W. Z
* x/ L+ e0 t) r) n7 r8 H" Z& p& s0 B
清单 1. 内存样本（test1.c） # b1 l' V! I5 e, }
0 z/ U; O; i8 a8 G
#include
#include 8 L2 ^6 U- j" ]2 t+ C
#include "memwatch.h" 0 u* j2 \9 o  ^1 A

int main(void) 6 s: J- ~0 c/ }# H4 J3 F4 y- j. x
{ 7 k5 [% D' T' ^7 s; q# Y2 W0 p3 Q. b
char *ptr1; . y, ^9 M+ V) r6 \
char *ptr2; ' j1 n( L# h! E1 `' V

ptr1 = malloc(512);
ptr2 = malloc(512); . C- P0 d3 L7 {8 W0 Q3 q( c

ptr2 = ptr1;
free(ptr2);
free(ptr1); 9 w' r2 _1 h9 y: y* h
}
2 g! z8 O5 L; n% d
清单 1 中的代码将分配两个 512 字节的内存块，然后指向第一个内存块的指针被设定为指向第二个内存块。结果，第二个内存块的地址丢失，从而产生了内存泄漏。
现在我们编译清单 1 的 memwatch.c。下面是一个 makefile 示例：
test1
gcc -DMEMWATCH -DMW_STDIO test1.c memwatch c -o test17 v6 _# U) F/ V* p; M0 p2 l- S
当您运行 test1 程序后，它会生成一个关于泄漏的内存的报告。清单 2 展示了示例 memwatch.log 输出文件。 , B* q9 |0 Y+ H/ n' j, J3 x6 j2 _

清单 2. test1 memwatch.log 文件 2 {5 A9 S& Z5 h: \

MEMWATCH 2.67 Copyright (C) 1992-1999 Johan Lindh - D7 O3 M+ G7 I7 Q

...
double-free: <4> test1.c(15), 0x80517b4 was freed from test1.c(14)
... 3 x. Q7 q' z- G, Y2 }( k
unfreed: <2> test1.c(11), 512 bytes at 0x80519e4 3 }8 W2 M2 j. P+ _; O' A
{FE FE FE FE FE FE FE FE FE FE FE FE ..............} ' u3 n$ r% w/ K6 r6 a6 l7 T

Memory usage statistics (global):
N)umber of allocations made: 2 - b% K+ r! E4 \
L)argest memory usage : 1024 3 k2 }; ^# p4 y- `  e5 T( O" R
T)otal of all alloc() calls: 1024
U)nfreed bytes totals : 512
MEMWATCH 为您显示真正导致问题的行。如果您释放一个已经释放过的指针，它会告诉您。对于没有释放的内存也一样。日志结尾部分显示统计信息，包括泄漏了多少内存，使用了多少内存，以及总共分配了多少内存。 $ M9 p" R, S4 |- p- ^" E
YAMD& m1 w  \( E" X0 T( |
YAMD 软件包由 Nate Eldredge 编写，可以查找 C 和 C 中动态的、与内存分配有关的问题。在撰写本文时，YAMD 的最新版本为 0.32。请下载 yamd-0.32.tar.gz（请参阅参考资料）。执行 make 命令来构建程序；然后执行 make install 命令安装程序并设置工具。 9 `* c% n8 p; Z0 L! t: B/ T
一旦您下载了 YAMD 之后，请在 test1.c 上使用它。请删除 #include memwatch.h 并对 makefile 进行如下小小的修改：
使用 YAMD 的 test1
8 K- w8 ?' k8 Z
gcc -g test1.c -o test1

清单 3 展示了来自 test1 上的 YAMD 的输出。
清单 3. 使用 YAMD 的 test1 输出 2 ]  D' `! B4 O3 Q) J! B( l  ^: M
YAMD version 0.32 4 h( o6 h' Z: u5 y2 c8 _
Executable: /usr/src/test/yamd-0.32/test1 ; L7 ~, U  a& l: W
...
INFO: Normal allocation of this block : o! J4 D. c( E2 |: u% |# ~
Address 0x40025e00, size 512
...
INFO: Normal allocation of this block
Address 0x40028e00, size 512 : B7 Y" O( I+ o$ S8 B) a
...
INFO: Normal deallocation of this block # i2 E$ u# V, R/ p
Address 0x40025e00, size 512
...
ERROR: Multiple freeing At ) T1 G2 f# N& f  e* j
free of pointer already freed
Address 0x40025e00, size 512
... & t0 a1 X& Q& O, Y9 v
WARNING: Memory leak
Address 0x40028e00, size 512 : O0 J! ]; J5 z- p
WARNING: Total memory leaks:
1 unfreed allocations totaling 512 bytes
% Q1 O" C2 j3 N$ B- [$ s
*** Finished at Tue ... 10:07:15 2002 . W, [- w0 `2 k; D# }0 z
Allocated a grand total of 1024 bytes 2 allocations + l1 X; u8 Z1 j! a- e+ c; _
Average of 512 bytes per allocation
Max bytes allocated at one time: 1024 " J7 W& ]  s  Q' a
24 K alloced internally / 12 K mapped now / 8 K max
Virtual program size is 1416 K
End.( c: ?. |* b; x$ c; i( b- @. q
YAMD 显示我们已经释放了内存，而且存在内存泄漏。让我们在清单 4 中另一个样本程序上试试 YAMD。

清单 4. 内存代码（test2.c） " ?1 q2 v: ?2 \  w

#include : A6 Y. |% e4 J5 h1 p3 J# n
#include

int main(void)
{ ; l3 E$ ?: @8 u4 B
char *ptr1; . Z5 R3 b4 d9 ?) e9 B2 n/ D( `
char *ptr2;
char *chptr; * ]# e" D2 E! }; A% n2 a
int i = 1;
ptr1 = malloc(512); 9 q5 b$ _" r- q3 z* a- ]
ptr2 = malloc(512); 2 R2 ~9 j; Y, c# i
chptr = (char *)malloc(512);
for (i; i <= 512; i  ) { $ E5 q) n1 N1 V$ I% R& S
chptr = 'S'; $ ]- {3 o, |, p; q8 n) p
}
) I" D, L0 q( Z0 P0 {9 mptr2 = ptr1; " A6 J2 U, I6 }& a( j
free(ptr2); . l6 m! S5 E! b4 c- k& Y
free(ptr1); % o6 N' G7 \; _
free(chptr);
+ Y/ G0 p7 o5 @" n7 p* Z}; O7 q+ V; C* T" i" A. ?  N+ K8 R7 J' P2 Z
您可以使用下面的命令来启动 YAMD：
( Y3 {3 h  G  S* T./run-yamd /usr/src/test/test2/test2 * v/ m) x( }; `: \5 d9 }/ @

$ B! [; L6 U: B- J: G清单 5 显示了在样本程序 test2 上使用 YAMD 得到的输出。YAMD 告诉我们在 for 循环中有“越界（out-of-bounds）”的情况。
# x1 S3 a6 z3 @% W/ f清单 5. 使用 YAMD 的 test2 输出 # S+ I- p9 K2 F9 U; ~
5 Z7 z+ s# q7 }+ ]; p" ~0 o
Running /usr/src/test/test2/test2 0 P5 g. U1 A. D7 I, }
Temp output to /tmp/yamd-out.1243
, [) C* J8 X+ d! E" Q0 a*********
: J% Z& h( Z  I) h7 g9 c./run-yamd: line 101: 1248 Segmentation fault (core dumped)
% n; G) X" \6 wYAMD version 0.32
' B2 U8 c* ~9 C  ]Starting run: /usr/src/test/test2/test2 8 b4 k( [5 x- X0 r. l
Executable: /usr/src/test/test2/test2 8 N# ]* P" \7 ^. y
Virtual program size is 1380 K
2 I8 a" D! C% e' y+ ?. F...
1 l# p5 \0 q- {; wINFO: Normal allocation of this block 5 j+ a* N; V* l  c
Address 0x40025e00, size 512
# S& o, Y  a, v- {# r+ e1 N...
- e0 m# u5 i8 q) t: a+ w, jINFO: Normal allocation of this block 5 r! f1 |! o/ Y2 S! ~
Address 0x40028e00, size 512
) p7 z& D% K9 |9 e... ; C9 u# D% t# Q9 }; H, o7 h& M, O
INFO: Normal allocation of this block 8 D+ Z  \/ f% y" W/ T0 v) ?9 C9 j5 ]' O
Address 0x4002be00, size 512 , [, Y  ]2 L; D% d
ERROR: Crash
+ D- n+ O9 h0 w: s9 b4 F% N3 N...   `5 ?1 [" ?5 Z! h" q7 I% y0 h
Tried to write address 0x4002c000   ~$ E& y" O8 w3 ^+ F
Seems to be part of this block: 1 q" x* K$ ^- ]! t( ?
Address 0x4002be00, size 512
' U" d3 o  R1 K0 ?( T... $ {5 v- n) b$ z0 u# V$ H& l$ p
Address in question is at offset 512 (out of bounds)
2 `  s8 L/ s: I7 d( wWill dump core after checking heap.
( D7 m. h! }; p  N) N9 T- UDone." G/ u5 Y9 ]  i/ n4 s/ ?* W6 K
MEMWATCH 和 YAMD 都是很有用的调试工具，它们的使用方法有所不同。对于 MEMWATCH，您需要添加包含文件 memwatch.h 并打开两个编译时间标记。对于链接（link）语句，YAMD 只需要 -g 选项。
7 L* P  J  T: }0 E1 eElectric Fence  ' i! G5 x3 a) I" K5 w
多数 Linux 分发版包含一个 Electric Fence 包，不过您也可以选择下载它。Electric Fence 是一个由 Bruce Perens 编写的 malloc() 调试库。它就在您分配内存后分配受保护的内存。如果存在 fencepost 错误（超过数组末尾运行），程序就会产生保护错误，并立即结束。通过结合 Electric Fence 和 gdb，您可以精确地跟踪到哪一行试图访问受保护内存。 Electric Fence 的另一个功能就是能够检测内存泄漏。
2 y5 A& _: X' M) H7 @8 E
3 a: u0 N& J! r5 n5 `* ?strace 命令是一种强大的工具，它能够显示所有由用户空间程序发出的系统调用。strace 显示这些调用的参数并返回符号形式的值。 strace 从内核接收信息，而且不需要以任何特殊的方式来构建内核。将跟踪信息发送到应用程序及内核开发者都很有用。在清单 6 中，分区的一种格式有错误，清单显示了 strace 的开头部分，内容是关于调出创建文件系统操作（mkfs）的。strace 确定哪个调用导致问题出现。
- @6 g# t6 ~+ l% a" x! b
6 t/ N# _8 s# h# K清单 6. mkfs 上 strace 的开头部分 ( Y) t& l% V) k' L# Y% ~
2 j& @9 ]% C! y
execve("/sbin/mkfs.jfs", ["mkfs.jfs", "-f", "/dev/test1"], &;amp; 6 Q6 J- W% ?$ D. a+ J1 d! G
... * Q3 Y7 _, Q8 b3 j5 n: w
open("/dev/test1", O_RDWR|O_LARGEFILE) = 4
0 G! Y6 q3 E  q( q6 O0 |0 \4 T! hstat64("/dev/test1", {st_mode=&;amp;, st_rdev=makedev(63, 255), ...}) = 0 ; n1 d4 e; Y/ \$ Z( g; v
ioctl(4, 0x40041271, 0xbfffe128) = -1 EINVAL (Invalid argument) / g& K: G+ m8 ~( }8 w/ @
write(2, "mkfs.jfs: warning - cannot setb" ..., 98mkfs.jfs: warning -
, I/ v$ F0 H# q5 r; Dcannot set blocksize on block device /dev/test1: Invalid argument ) & a- Z4 |( j' Z0 I! a8 q
= 98 * D3 }" f1 j- H( y( y- K/ \
stat64("/dev/test1", {st_mode=&;amp;, st_rdev=makedev(63, 255), ...}) = 0
1 ]' K* \; q: J8 ?4 Z* yopen("/dev/test1", O_RDONLY|O_LARGEFILE) = 5
% Z, V) d6 D- ^5 l( N, a. |ioctl(5, 0x80041272, 0xbfffe124) = -1 EINVAL (Invalid argument) ' M( Y* s- ~, i# m+ A4 f
write(2, "mkfs.jfs: can't determine device"..., ..._exit(1) ' Q6 P9 m% O# H0 M' L
= ? % P' X; ^& V; D# x# u& I  p
清单 6 显示 ioctl 调用导致用来格式化分区的 mkfs 程序失败。ioctl BLKGETSIZE64 失败。（BLKGET- SIZE64 在调用 ioctl 的源代码中定义。) BLKGETSIZE64 ioctl 将被添加到 Linux 中所有的设备，而在这里，逻辑卷管理器还不支持它。因此，如果 BLKGETSIZE64 ioctl 调用失败，mkfs 代码将改为调用较早的 ioctl 调用；这使得 mkfs 适用于逻辑卷管理器。
; [: n& o) Q( h" c, T: \: z- ~1 \; i/ p3 x
zhchhui 回复于：2003-09-15 10:57:11
( r" i: S+ ^1 P: ^& |) R5 M第 3 种情况：使用 gdb 和 Oops
  S7 O  m4 n7 k$ S4 C2 n* s3 W您可以从命令行使用 gdb 程序（Free Software Foundation 的调试器）来找出错误，也可以从诸如 Data Display Debugger（DDD）这样的几个图形工具之一使用 gdb 程序来找出错误。您可以使用 gdb 来调试用户空间程序或 Linux 内核。这一部分只讨论从命令行运行 gdb 的情况。 , s9 s, u5 w0 ]: v  B
使用 gdb program name 命令启动 gdb。gdb 将载入可执行程序符号并显示输入提示符，让您可以开始使用调试器。您可以通过三种方式用 gdb 查看进程：
5 h4 A) E1 D# c5 Y  k2 ??使用 attach 命令开始查看一个已经运行的进程；attach 将停止进程。 " |2 \) G+ q- e/ J
?使用 run 命令执行程序并从头开始调试程序。
9 r6 `/ [* E  D# i) [?查看已有的核心文件来确定进程终止时的状态。要查看核心文件，请用下面的命令启动 gdb。
% |% ?. r; E6 |7 V* X( _  C; Pgdb programname corefilename # {: c7 ]2 D6 k
要用核心文件进行调试，您不仅需要程序的可执行文件和源文件，还需要核心文件本身。要用核心文件启动 gdb，请使用 -c 选项： ) s& t0 |7 Q: m: O* H9 b, C
gdb -c core programname + b" C3 `' n9 M. `* }0 {% P. j
gdb 显示哪行代码导致程序发生核心转储。
' _) p2 F3 N7 @0 H+ ]6 R/ R3 x; q
) E4 ~) K1 j8 k* D+ c9 `* p$ H在运行程序或连接到已经运行的程序之前，请列出您觉得有错误的源代码，设置断点，然后开始调试程序。您可以使用 help 命令查看全面的 gdb 在线帮助和详细的教程。 * F$ _0 v" C+ L; \5 `7 X6 D

; P, P- l8 {) b9 @3 k& nkgdb 程序（使用 gdb 的远程主机 Linux 内核调试器）提供了一种使用 gdb 调试 Linux 内核的机制。kgdb 程序是内核的扩展，它让您能够在远程主机上运行 gdb 时连接到运行用 kgdb 扩展的内核机器。您可以接着深入到内核中、设置断点、检查数据并进行其它操作（类似于您在应用程序上使用 gdb 的方式）。这个补丁的主要特点之一就是运行 gdb 的主机在引导过程中连接到目标机器（运行要被调试的内核）。这让您能够尽早开始调试。请注意，补丁为 Linux 内核添加了功能，所以 gdb 可以用来调试 Linux 内核。
3 z2 K1 ^6 L0 ^' {6 }' ^
' ]7 c  P' ]4 o& N使用 kgdb 需要两台机器：一台是开发机器，另一台是测试机器。一条串行线（空调制解调器电缆）将通过机器的串口连接它们。您希望调试的内核在测试机器上运行；gdb 在开发机器上运行。gdb 使用串行线与您要调试的内核通信。
, U+ n2 {  k6 Q4 ?! \2 W8 g' p" M; {: `. w  z
请遵循下面的步骤来设置 kgdb 调试环境：
  M' K0 C* A0 D" I. ?% h4 I1.下载您的 Linux 内核版本适用的补丁。
0 m/ \. b5 q" i: P4 T2 \; |2.将组件构建到内核，因为这是使用 kgdb 最简单的方法。（请注意，有两种方法可以构建多数内核组件，比如作为模块或直接构建到内核中。举例来说，日志纪录文件系统（Journaled File System，JFS）可以作为模块构建，或直接构建到内核中。通过使用 gdb 补丁，我们就可以将 JFS 直接构建到内核中。） 4 R: p5 v7 ^) c
3.应用内核补丁并重新构建内核。
& e# t& @2 W- T8 @4.创建一个名为 .gdbinit 的文件，并将其保存在内核源文件子目录中（换句话说就是 /usr/src/linux）。文件 .gdbinit 中有下面四行代码：
5 X$ ^: Y3 M/ |) Z) |oset remotebaud 115200
* W7 a; \& P& q" f* O* fosymbol-file vmlinux 2 k* S# x, V. Q* z
otarget remote /dev/ttyS0 ; \$ m5 q* ?# n- a  Z
oset output-radix 160 y1 I1 U1 Y6 g
6 l& ~9 r" s6 p, d
5.将 append=gdb 这一行添加到 lilo，lilo 是用来在引导内核时选择使用哪个内核的引导载入程序。
- D3 d; {  F2 h3 F2 m) moimage=/boot/bzImage-2.4.17 ) p) J; r! h; `% H6 P
olabel=gdb2417
  H; Q2 ]+ O' O6 f1 toread-only
, p3 i3 z4 Y/ g1 F3 Z: x( [oroot=/dev/sda8 & D8 j8 q6 p5 Q, t/ U: N- s- T
oappend="gdb gdbttyS=1 gdb-baud=115200 nmi_watchdog=0"  3 \& r% O* h5 v, h4 @% H4 q: G
清单 7 是一个脚本示例，它将您在开发机器上构建的内核和模块引入测试机器。您需要修改下面几项：
& _  Q- K0 }7 T1 Q3 ^4 K?best@sfb：用户标识和机器名。
  F# [5 K; d2 G; z?/usr/src/linux-2.4.17：内核源代码树的目录。 ( f4 P/ J* g5 w  ?
?bzImage-2.4.17：测试机器上将引导的内核名。
& m% _4 r) E: R; G1 l?rcp 和 rsync：必须允许它在构建内核的机器上运行。 : }- o  t% W# x# Q# W1 L
清单 7. 引入测试机器的内核和模块的脚本 ( z1 x( I. f5 `% f8 }2 T2 f' p' z+ {
* |; `1 D2 W% {" G9 y6 ~. [+ ?6 x
set -x
, G! ]5 T; s8 K. e" |' ercp best@sfb: /usr/src/linux-2.4.17/arch/i386/boot/bzImage /boot/bzImage-2.4.17 2 x( q9 ~: c; {" u. B
rcp best@sfb:/usr/src/linux-2.4.17/System.map /boot/System.map-2.4.17
. s6 R6 U2 `, P" R2 I* Arm -rf /lib/modules/2.4.17 * q; h) Q" L6 L' B0 k$ _
rsync -a best@sfb:/lib/modules/2.4.17 /lib/modules 0 S# ]' u4 x/ U6 P" {: B
chown -R root /lib/modules/2.4.17 4 C* G6 ]5 P. a! }1 e
lilo
& U& B# I& a7 p8 y' s3 f现在我们可以通过改为使用内核源代码树开始的目录来启动开发机器上的 gdb 程序了。在本示例中，内核源代码树位于 /usr/src/linux-2.4.17。输入 gdb 启动程序。
如果一切正常，测试机器将在启动过程中停止。输入 gdb 命令 cont 以继续启动过程。一个常见的问题是，空调制解调器电缆可能会被连接到错误的串口。如果 gdb 不启动，将端口改为第二个串口，这会使 gdb 启动。
- l7 E6 Y, c8 n3 o7 n, d使用 kgdb 调试内核问题
* n9 O# C4 w1 q3 h: A+ u清单 8 列出了 jfs_mount.c 文件的源代码中被修改过的代码，我们在代码中创建了一个空指针异常，从而使代码在第 109 行产生段错误。
! T' B3 e% ^, H( ]' b清单 8. 修改过后的 jfs_mount.c 代码
: c0 B; x( C4 k. {$ g) [' K9 X$ |: K( B& Q3 N
int jfs_mount(struct super_block *sb)
7 A+ d4 D- @# p( f1 K{ , \4 j, [  p% d& z" W8 |8 @$ E0 x; J
...
. j$ {: ^! x0 @3 tint ptr; /* line 1 added */
0 S. ?, z/ [# Z( j& Z6 E' q1 CjFYI(1, (" , ~# I  ^: S; n7 w& m
Mount JFS , v/ E9 J6 x+ o' K0 a
")); ' B- y! h" P7 j" _: e1 d# V7 w
/ * . a% ]1 G5 M2 V1 O) V
* read/validate superblock 4 {* Y2 k6 ~  G
* (initialize mount inode from the superblock) , I$ Y) d; ?: w' F7 a
* /
% G% q4 |1 r' W. Y* T3 mif ((rc = chkSuper(sb))) { * p& I8 I& @% y) ~# A5 l. o
goto errout20;
' |- {0 m+ Q+ Z2 ]}
! P9 I+ N  `" v7 `# E5 n/ t108 ptr=0; /* line 2 added */ ; k% i$ C% J/ W$ R
109 printk("%d
6 \3 j" r3 C) M9 A: u  S",*ptr); /* line 3 added */; S9 x6 H* N' D# z- O/ n
清单 9 在向文件系统发出 mount 命令之后显示一个 gdb 异常。kgdb 提供了几条命令，如显示数据结构和变量值以及显示系统中的所有任务处于什么状态、它们驻留在何处、它们在哪些地方使用了 CPU 等等。清单 9 将显示回溯跟踪为该问题提供的信息；where 命令用来执行反跟踪，它将告诉被执行的调用在代码中的什么地方停止。
1 D" ?$ |6 Z9 j; C' V清单 9. gdb 异常和反跟踪
& m- J8 q1 R& E' k/ f  Y- L3 \' C- _3 t' t' t) {. A( m
mount -t jfs /dev/sdb /jfs
1 D' O8 ~6 N6 `9 t8 W! _
$ v+ c! e% T* u0 n& p# jProgram received signal SIGSEGV, Segmentation fault. 7 I3 ~: G" n- g# a, f' x- W
jfs_mount (sb=0xf78a3800) at jfs_mount.c:109   P4 j; T4 R, g& T
109 printk("%d
5 A  ~" O4 @" B  L) d" r+ _- |",*ptr);
/ u7 p# G3 R  C# G( H& j, p(gdb)where 3 Y3 c* n. L4 ~6 z- ?2 y
#0 jfs_mount (sb=0xf78a3800) at jfs_mount.c:109 ; [' p+ `2 a$ Z. g. D
#1 0xc01a0dbb in jfs_read_super ... at super.c:280
- Z# F# @  |" F( r) b8 ?- q#2 0xc0149ff5 in get_sb_bdev ... at super.c:620 * T+ w8 Y! k2 i8 |
#3 0xc014a89f in do_kern_mount ... at super.c:849 1 `) M9 F' [5 \8 p
#4 0xc0160e66 in do_add_mount ... at namespace.c:569 4 j7 s: G) P  [2 \" p
#5 0xc01610f4 in do_mount ... at namespace.c:683 4 r7 I* L' j0 {7 o
#6 0xc01611ea in sys_mount ... at namespace.c:716
/ Y) ?% T4 T8 G: G#7 0xc01074a7 in system_call () at af_packet.c:1891
0 d7 m' Q5 H  @#8 0x0 in ?? () ! x# a) Z6 ?8 F/ [  B2 _8 e
(gdb)
+ V% |/ n: m: |. t下一部分还将讨论这个相同的 JFS 段错误问题，但不设置调试器，如果您在非 kgdb 内核环境中执行清单 8 中的代码，那么它使用内核可能生成的 Oops 消息。
: I. @7 q  X8 ZOops 分析
, O) h+ d0 j1 |' L6 z7 @Oops（也称 panic，慌张）消息包含系统错误的细节，如 CPU 寄存器的内容。在 Linux 中，调试系统崩溃的传统方法是分析在发生崩溃时发送到系统控制台的 Oops 消息。一旦您掌握了细节，就可以将消息发送到 ksymoops 实用程序，它将试图将代码转换为指令并将堆栈值映射到内核符号。在很多情况下，这些信息就足够您确定错误的可能原因是什么了。请注意，Oops 消息并不包括核心文件。
1 k' O( ]& }' s. t3 {# \让我们假设系统刚刚创建了一条 Oops 消息。作为编写代码的人，您希望解决问题并确定什么导致了 Oops 消息的产生，或者您希望向显示了 Oops 消息的代码的开发者提供有关您的问题的大部分信息，从而及时地解决问题。Oops 消息是等式的一部分，但如果不通过 ksymoops 程序运行它也于事无补。下面的图显示了格式化 Oops 消息的过程。
1 S; q% z. X/ r; }$ O格式化 Oops 消息
- W# c) Q  O$ F( T. B( ?
5 k7 l. u5 ^7 m; c* ?ksymoops 需要几项内容：Oops 消息输出、来自正在运行的内核的 System.map 文件，还有 /proc/ksyms、 vmlinux 和 /proc/modules。关于如何使用 ksymoops，内核源代码 /usr/src/linux/Documentation/oops-tracing.txt 中或 ksymoops 手册页上有完整的说明可以参考。Ksymoops 反汇编代码部分，指出发生错误的指令，并显示一个跟踪部分表明代码如何被调用。 9 J5 S( x. c/ @. {7 {; i8 d
首先，将 Oops 消息保存在一个文件中以便通过 ksymoops 实用程序运行它。清单 10 显示了由安装 JFS 文件系统的 mount 命令创建的 Oops 消息，问题是由清单 8 中添加到 JFS 安装代码的那三行代码产生的。 8 T, O* w6 J$ I) z$ Z
清单 10. ksymoops 处理后的 Oops 消息 , {# x& E0 a% n- n7 r

4 ^$ b: [0 M/ s* H- A6 H& F; oksymoops 2.4.0 on i686 2.4.17. Options used 2 J% C0 [2 ^" S. l: O9 @1 q
... 15:59:37 sfb1 kernel: Unable to handle kernel NULL pointer dereference at
+ Q, [1 ^, \! a; E( B' Svirtual address 0000000
2 b: g7 @1 l* d0 c... 15:59:37 sfb1 kernel: c01588fc $ ?% k, Q  s' H$ M
... 15:59:37 sfb1 kernel: *pde = 0000000
3 `& G4 u1 j& d... 15:59:37 sfb1 kernel: Oops: 0000 8 c) ?0 J( u# Y/ y7 D7 V9 ?
... 15:59:37 sfb1 kernel: CPU: 0 8 U" O: S0 D/ ]  W
... 15:59:37 sfb1 kernel: EIP: 0010:[jfs_mount 60/704] $ k- \& X- ]6 [6 L- S& U7 w
/ R" T$ E2 Q. a3 g
... 15:59:37 sfb1 kernel: Call Trace: [jfs_read_super 287/688]
% r6 c7 s% q3 B: }/ m% F[get_sb_bdev 563/736] [do_kern_mount 189/336] [do_add_mount 35/208]
+ G2 [/ z1 T* B2 |$ \5 z: H[do_page_fault 0/1264]
  I2 b+ ]6 p- ^. @' R- s... 15:59:37 sfb1 kernel: Call Trace: []... ' F8 d  H5 ]. b; q& s
... 15:59:37 sfb1 kernel: [... 15:59:37 sfb1 kernel: Code: 8b 2d 00 00 00 00 55 ...
& y: ~) D3 z. p7 U
0 e+ L6 x$ J7 Q5 I>>EIP; c01588fc <===== ; [" V% W, V% y5 n
...
& F7 [6 v- |4 m& _* M, V+ _5 KTrace; c0106cf3 , g5 b7 B' G: }* f2 J" x. a2 C
Code; c01588fc ! ?; I% l7 m% f
00000000 <_EIP>: & e; \) x0 [( ?0 t* ?
Code; c01588fc <===== : O/ Q+ R* I& W; |
0: 8b 2d 00 00 00 00 mov 0x0,雙 <=====
. F1 `( d7 ?8 pCode; c0158902
/ i2 D* t4 \& Q9 Q' `: _& g6: 55 push 雙
- I# o* y0 X4 v! ~. D( G' Z, `接下来，您要确定 jfs_mount 中的哪一行代码引起了这个问题。Oops 消息告诉我们问题是由位于偏移地址 3c 的指令引起的。做这件事的办法之一是对 jfs_mount.o 文件使用 objdump 实用程序，然后查看偏移地址 3c。Objdump 用来反汇编模块函数，看看您的 C 源代码会产生什么汇编指令。清单 11 显示了使用 objdump 后您将看到的内容，接着，我们查看 jfs_mount 的 C 代码，可以看到空值是第 109 行引起的。偏移地址 3c 之所以很重要，是因为 Oops 消息将该处标识为引起问题的位置。
8 W5 _, E4 v( u) H/ _/ L清单 11. jfs_mount 的汇编程序清单 ; k0 F* B' p/ l3 K8 I

/ z! t% u) u. p( b3 N  [0 G* t109 printk("%d 0 H4 {, O+ ^3 a: n0 [. i) M2 a
",*ptr);
' D/ B, O6 u* M6 J8 }5 c- K& f5 m
9 |0 q! G$ u  R0 ~: `objdump jfs_mount.o # c# l# t- V: n1 J) }6 e
6 }* }* w  }! i, C. V6 h* D5 F$ ]
jfs_mount.o: file format elf32-i386
+ g) B! ^( Q: `, J& e2 D$ h
4 `3 c" z  n; `! DDisassembly of section .text:
* Z) p* r( I1 Y' ^+ @3 F; r5 g% v2 F7 z* R  v
00000000 :
4 o  r: [7 g9 L" S. ]0:55 push 雙
: _1 O' L# M: x: z. ]...
1 [& r  L; d/ p+ l0 W" l# W9 X2c: e8 cf 03 00 00 call 400
- \5 g7 C6 F# J/ M; }7 q1 K31: 89 c3 mov 陎,離
; C$ |* f  V* L/ Y4 s5 i33: 58 pop 陎
5 `8 [( n, O: O34: 85 db test 離,離
$ v1 D" k% z9 y, d% R36: 0f 85 55 02 00 00 jne 291 $ ?) U& V# y8 o8 |2 B( ^* D+ w/ Y
3c: 8b 2d 00 00 00 00 mov 0x0,雙 << problem line above 4 d' s2 J$ \8 A. \4 d6 q
42: 55 push 雙 $ [4 V( v* d' L% R
kdb& j- [/ f% ^" K$ p
Linux 内核调试器（Linux kernel debugger，kdb）是 Linux 内核的补丁，它提供了一种在系统能运行时对内核内存和数据结构进行检查的办法。请注意，kdb 不需要两台机器，不过它也不允许您像 kgdb 那样进行源代码级别上的调试。您可以添加额外的命令，给出该数据结构的标识或地址，这些命令便可以格式化和显示基本的系统数据结构。目前的命令集允许您控制包括以下操作在内的内核操作：
  E9 g# L4 b/ q?处理器单步执行
9 @. a: `- J$ G  N2 M: _?执行到某条特定指令时停止 . `* P9 n& p& \
?当存取（或修改）某个特定的虚拟内存位置时停止 $ T9 @+ D+ J6 F+ M+ B4 d
?当存取输入／输出地址空间中的寄存器时停止 ; s# X: I* k" J$ I1 U: Q
?对当前活动的任务和所有其它任务进行堆栈回溯跟踪（通过进程 ID）
6 u% _; D9 C4 n& m2 I9 W?对指令进行反汇编
  v. U6 u9 ^: F' Q追击内存溢出 ! F4 B: C! k* Z9 W) I" J
您肯定不想陷入类似在几千次调用之后发生分配溢出这样的情形。
, b0 m) M; w3 T我们的小组花了许许多多时间来跟踪稀奇古怪的内存错误问题。应用程序在我们的开发工作站上能运行，但在新的产品工作站上，这个应用程序在调用 malloc() 两百万次之后就不能运行了。真正的问题是在大约一百万次调用之后发生了溢出。新系统之所有存在这个问题，是因为被保留的 malloc() 区域的布局有所不同，从而这些零散内存被放置在了不同的地方，在发生溢出时破坏了一些不同的内容。 6 C  P  i. v' f& \: K
我们用多种不同技术来解决这个问题，其中一种是使用调试器，另一种是在源代码中添加跟踪功能。在我职业生涯的大概也是这个时候，我便开始关注内存调试工具，希望能更快更有效地解决这些类型的问题。在开始一个新项目时，我最先做的事情之一就是运行 MEMWATCH 和 YAMD，看看它们是不是会指出内存管理方面的问题。
/ ^2 O# H8 h7 J! g1 E6 `* E. y' b! B. f内存泄漏是应用程序中常见的问题，不过您可以使用本文所讲述的工具来解决这些问题。

点击图标进入精品网摘收藏欢迎大家加入网络收藏夹

TOP

‹‹ 上一主题 | 下一主题 ››