2.1介绍
视频编码是对一个数字视频信号的编码和解码的过程.这一章讨论了数字图象和视频信号的结构和特征以及对于视频编码来说很重要的一些基本概念,比如采样格式等.数字视频是对于一人自然的视觉场景的从时间和空间上进行采样的表示方式.一个场景是由通过在时间上对于点进行采样来得到帧从而产生的(一种对于在时间上点在整个视频场景中的表示方法)或是一个场(由奇数或偶数行的空间采样组成).采样在一定的时间间隔上(通常是1/25或1/30秒时间间隔)进行重复，从而产生一个可动的视频信号。一般来说，需要三种采样集来表示一个有色的场景。表示数字视频的流行的方法是使用ITU-R 601标准并使用"中间集"。对于一个视觉场景的重建的准确性必须被计算来决定一个视频通信系统的性能，这是一个出了名的困难和极为不准确的过程。主观的测量方法是极耗时间而且它与观察者对于变换的反应程序不同而不同。客观的测量方法实现起来就更简单一些，但是目前还不能与人类实际视觉感完完全全匹配。

2.2 自然视频场景

一个经典的“现实世界”或“自然世界“的视频场景是由多个有各自特征形状，深度，纹理和亮度的物体构成的。视频场景的颜色和明亮度在不同的场景中根据不同程序的光滑度而定。一个与视频处理和压缩相关的经典的自然视频场景包括空间特征（纹理变换，物体的数目和形状，颜色等）和时间特征（物体运动，亮度的变化，视点的移动等）

2.3 捕捉
一个自然视频场景在空间和时间上是连续的。用数字的形式表示一个视频场景包括在空间对实际场景进行采样(通常是通过在视频图形面上用长方形格处理)和时间采样(以一系列以某时间间隔采样得到的静态帧组成)。数字视频就是在数字形式下的一个视频场景的采样的表示方式。每一个时-空采样（像素）用一个数或一组数来表示，用来描述采样点的亮度和色度。

为了得到一个二维的采样图像，摄像头把一个视频场景的二维投影聚焦到传感器上，比如一组电荷耦合装置(CCD)。在带色的图像捕捉过程中，每一个颜色成员都分别被过滤并投影到一组CCD中。

2.3.1 空间采样
一组CCD的输出就是一个模拟的视频信号，一组可以表示一个视频图像的电信号。在时间上对一点进行采样就形成了一个有定值的采样点图像或帧。最常用的采样方法是把采样点置于一个正方形或长方形格中进行操作。然后对于每个格交点处的点进行采样，重建过程就以采样值对应到像素上进行显示。重建图的视觉效果取决于采样点的数量。选择一个粗糙的采样格会得到一个低分辨率的采样图像，而增加采样点的数量就会增加采样图像的分辨率。

2.3.2 时间采样
一个可动的视频图像是通过对信号在周期性的时间间隔上进行快照得到的。重放这一系列的帧会得到一个运动的效果。一个高的时间采样率(帧率)会产生更加平滑的运动但是它就要求有更多的采样要被捕捉并被保存。在10帧每秒之下的帧率有些被用于一些很低码率的视频通信中(因为被传输的数据量非常的小)但是运动却看起来很笨拙而且不自然。在10-20帧每秒是比较经典的低码率视频。在25-30帧每秒进行采样是标准电视信号图象的采样帧率(配合隔行扫描采样来达到更好的运动效果）。50-60帧每秒就可以形成平滑的运动(代价就是帧率太过高，传输和存储的压力大).

2.3.3 帧和场
一个视频信号可以被通过对于一系列帧(渐进采样)或一个序列的隔行扫描的场(隔行扫描采样)来进行采样。在一个隔行扫描采样的视频序列里，一帧的一半的数据是在每个时间采样间隔进行采样的。一个场由奇数个或偶数个扫描线组成，而一个隔行扫描的视频序列包括一系列的视频帧。这种采样方式的优点在于与有相同帧数的同样码率的渐进序列相比，可以在一秒中传输两倍多的场，这样就可以形成更加平滑的运动。比如，一个PAL视频序列由50场/秒的码率组成，在回放过程中，运动可以比与之相同的25帧每秒的用渐进视频序列形成的运动显得更加的平滑。

2.4 颜色空间
大多数数字视频程序都依赖于彩色视频的显示，这样的话，就需要一个来捕捉并表示颜色空间的表示方法。一个单色的图像只需要一个在空间内表示一个像素点的亮度或流明度的值就可以了。但对于颜色图像来说，对于一个像素点至少需要三个数来把颜色信息准确地表示出来。用来表示亮度和颜色的方法叫做颜色空间。

2.4.1 RGB
在RGB颜色空间中，一个带颜色的图象采样是用三个值来表示一个象素点的相对的红，绿和蓝色比(三种光线的主样构成颜色)。任何颜色都可以通过把红，绿和蓝来通过不同的比例相混得到。RGB颜色空间更加适合于捕捉并显示颜色图像。捕捉RGB图像包括过滤出红，绿和蓝色的构成比率，并用一个单独的传感器数组来捕捉。CRT和LCD通过分别对每个像素点的红绿蓝值进行显示来得到各种颜色。从一个通常的观察距离来看，不同的构成部分可以达到颜色上的真实感。

2.4.2 YCbCr
人类视觉系统(HVS)相比亮度来说对于颜色不是那么敏感的。在RGB颜色空间中，三种颜色被平等地看待，并用相同的分辨率存放起来。但是通过把亮度与颜色信息分离，并对亮度值取更高的分辨率可以更有效地表示一个颜色图像。

YCbCr颜色空间和它的变换(通常写为YUV)是一种流行而高效的表示一个颜色图像的方法。Y是亮度值，由R,G,B的加权平均可以得到： Y=krR + kgG + kbB
这里k是加权因子。

颜色信号可以由不同的颜色差别来表示：
Cb = B-Y
Cr = R-Y
Cg = G-Y
对于一个颜色图像的完整的描述由给定Y和三个色差:Cb,Cr,Cg来表示。

目前为止，我们的表示方法好像并不那么好，因为相比RGB表示来说，我们这次用了四个参数。然后Cb+Cr+Cg是一个常数，那么我们只需要两个色度参数就可以了，第三个可以通过其他两个计算出来。在YCbCr空间中，只有Y和Cb,Cr值被传输和存储，而且Cb和Cr的分辨率可以比Y低，因为人类视觉系统对于亮度更加敏感。这就减少了表示图像的数据量。通常的观察情况下，RGB和YCbCr表示的图像看上去没有什么不同。对于色度采用比亮度低的分辨率进行采样是一种简单而有效的压缩办法。

一个RGB图像可以在捕捉之后转换为YCbCr格式用来减少存储和传输负担。在显示图象之前，再转回为RGB.注意没有必要去指明分别的加权值kg（因为kb+kr+kg=1)，而且G可以从YCbCr中解压出来，这说明不需要存储和传输Cg参数。

Y = kr R + (1-kb-kr)G + kb B
Cb = 0.5/(1-kb) * (B-Y)
Cr = 0.5/(1-kr) * (R-Y)

R = Y + (1-kr)/0.5 * Cr
G = Y - 2kb(1-kb)/(1-kb-kr) * Cb - 2kr(1-kr)/(1-kb-kr) * Cr
B = Y + (1-kb)/0.5 * Cb

ITU-R的BT.601决议定义了kb=0.114,kr=0.299，那么代换参数就有了如下等式：

Y = 0.299R + 0.587G + 0.114B
Cb = 0.564(B - Y )
Cr = 0.713(R - Y )

R = Y + 1.402Cr
G = Y - 0.344Cb - 0.714Cr
B = Y + 1.772Cb

2.4.3 YCbCr采样格式
4:4:4采样就是说三种元素Y,Cb,Cr有同样的分辨率,这样的话,在每一个像素点上都对这三种元素进行采样.数字4是指在水平方向上对于各种元素的采样率,比如说,每四个亮度采样点就有四个Cb的Cr采样值.4:4:4采样完整地保留了所有的信息值.4:2:2采样中(有时记为YUY2),色度元素在纵向与亮度值有同样的分辨率,而在横向则是亮度分辨率的一半(4:2:2表示每四个亮度值就有两个Cb和Cr采样.)4:2:2视频用来构造高品质的视频彩色信号.

在流行的4:2:0采样格式中(常记为YV12)Cb和Cr在水平和垂直方向上有Y分辨率的一半.4:2:0有些不同，因为它并不是指在实际采样中使用4:2:0，而是在编码史中定义这种编码方法是用来区别于4:4:4和4:2:2方法的).4:2:0采样被广泛地应用于消费应用中，比如视频会议，数字电视和DVD存储中。因为每个颜色差别元素中包含了四分之一的Y采样元素量，那么4:2:0YCbCr视频需要刚好4:4:4或RGB视频中采样量的一半。

4:2:0采样有时被描述是一个"每像素12位"的方法。这么说的原因可以从对四个像素的采样中看出.使用4:4:4采样，一共要进行12次采样，对每一个Y,Cb和Cr，就需要12*8=96位，平均下来要96/4=24位。使用4:2:0就需要6*8=48位，平均每个像素48/4=12位。

在一个4:2:0隔行扫描的视频序列中，对应于一个完整的视频帧的Y,Cb,Cr采样分配到两个场中。可以得到，隔行扫描的总采样数跟渐进式扫描中使用的采样数目是相同的。

2.5 视频格式
这本书中描述的视频压缩标准可以压缩很多种视频帧格式。实际中，捕捉或转化一个中间格式或一系列中间格式是很平常的事情。CIF就是一种常见的流行的格式，并由它衍生出了4CIF和Sub-QCif。帧分辨率的选择取决于应用程序，可使用的存储量以及传输带宽。比如说4CIF对于标准定义的电视和DVD视频来说是合适的,CIF和QCIF在视频会议中是常被使用的格式。QCIF和SQCIF对于移动设备的多媒体程序来说是合适的，在这样的情况下，显示分辨率和码率都是有限的。以下是各种格式的具体使用位数的需求（使用4:2:0采样，对于每个元素用8个位大小表示)：

格式： Sub-QCIF 亮度分辨率： 128*96  每帧使用的位: 147456
格式： QCIF  亮度分辨率： 176*144  每帧使用的位: 304128
格式： CIF  亮度分辨率： 352*288  每帧使用的位: 1216512
格式：  4CIF  亮度分辨率： 704*576  每帧使用的位: 4866048

一种在电视信号中被应用的很广的数字视频信号编码格式就是ITU-R的BT.601-5 提案。亮度元素被在13.5MHz下采样，而亮度值则在6.75MHz下采样，这样就形成了一个4:2;2的Y:Cb:Cr采样结果。采样数字信号的参数取决于视频码率(对于NTSC来说是30Hz,对于PAL/SECAM来说是25Hz)。NTSC的30Hz是对低空间分辨率的补偿，这样总的码率就是216Mbps.实际显示的激活部分的区域要比总量小，因为它去掉了在一帧边缘处的水平和垂直空白间隔。
每一个采样都有0-255的采样范围。0和255两个等级被留作同步，而且激活的亮度信号被限制到26(黑色）到235(白色)之间.

2.6 质量
为了指定，评价和比较视频通信系统，我们需要决定向观察者显示的视频图像的质量。衡量视频信号的质量是一件困难的事情，通常也是不准确的，因为有太多的因素会影响到衡量的结果了。视觉质量与生俱来就是主观的因素，它被很多因素影响着，这就使对于这个衡量结果的准确性变得更难了。比如说，一个视频信号的质量对于一个观察者来说主要取决于任务本身，比如说，被动地观看一部DVD影片，主动地参与一个视频会议，用符号评议进行通信交流，或是试图从一个视频场景中认出一个人。衡量视频信号的客观分类给定了一个准确的可重复的结果，但是没有哪种客观的测量方法可以完全地模拟人类视觉主观的感受。

2.6.1  主观质量测量
2.6.1.1 影响主观质量的因素
对于一个视频场景的感觉是由人类视觉系统对于不同元素复杂交互性决定的----眼睛和大脑.对于视频信号的感知是受空间保真度的影响的(不管有没有明显的失真，问题在于我们是否可以清楚地看到一个场景的各个部分)和时间保真度(运动是否自然平滑)。然而，一个观察者对于质量的看法经常会被观察环境，观察者的心情和观察者与场景的交互程序相关。一个执行特定任务的用户需要关注于视频场景的一部分。观察一个场景常与看一个电影时的对于“好”的概念是不同的。例如，一个观察者的对视频质量的看法在观察环境好的情况下会更好一些（而这一点不取决于视频信号本身的好坏）

其他的重要的影响因素包括视觉焦点（一个观察者通过一系列的观察点而不是同时观察所有的内容）和所谓的"最新效应"（我们对于一个视频序列的看法总是更多地受更新看到的内容的影响而不是老的内容)。所有的这些因素都让衡量一个视频的质量的好坏的任务变得极为困难。

2.6.1.2 ITU-R 500
很多的关于主观质量认下的测试过程都在ITU-R BT.500-11中被定义。一个常用的过程就是Double Stimulus Continuous Quality Scale(DSCQS)方法，评价者被展示了一系列的图片或两个视频序列A和B（一个接一个地），然后被要求给出A和B的质量评价值，方法是在五个分隔着的评价值（从"Excellent"到"Bad")画连续线来定。在一个典型的测试会话中，评价者被展示了一系列的序列，并被要求对它们进行评价。对于每对序列来说，一个是未受损的"参考“序列，另一个是同样的序列，它被在测试的系统或过程中修改了。

这两个序列的顺序，原始的和有损的，在测试地过程中被随机的给出，这样评价者就不知道哪个是原始的，哪个是改变过的序列。这样就防止了评价者带偏见地比交这两个测试序列。在结束的时候，评分被转化到一个规范化的范围内，最终的结果是用平均评价值来说的，用它来指明相应的帧的质量。

像DSCQS这样的测试被广泛地接受，并被用来评价主观的视频效果。然而，这样的测试受实际问题的影响。这样结果对于评价者来说差别会非常大。这个不同会被在重复测试的过程中被弥补过来。一个有经验的评价者(对视频压缩失真了解的比较多的）会比那些非有经验性的用户会给出一个更带偏见的评分。这就意味着一个很大的评价用户群是需要的，因为没有经验的用户很快会发现被改变的视频的一些特征。这些因素使得使用DSCQS方式的代价更大。

2.6.2 客观的质量测量
主观测量质量的方法的复杂性和消耗性让用算法自动测量质量要更加的吸引人。视频压缩的开发者和视频处理系统很大程序上依赖于所谓的客观质量测量方法。最广泛应用的方法是PSNR方法，但是这种方法的局限性使人们不得不找更加复杂的方法来逼近人类视觉性。

2.6.2.1 PSNR
PSNR是用来在对数级上描述质量，并且依赖于原始信号和改变后信号的均方差（MSE）:
PSNR(db) = 10log(10)(2^n-1)^2/MSE

PSNR可以很方便而快速地被计算出来，这样它就成为了一种很流行使用的方法，并用来测量压缩和解码视频图像的质量。

PSNR方法有几个局限性，PSNR需要一个原始的图像做为对比，但是这也许是无法在所有情况下都可以实现的,也难保所谓的原始图象没受过影响。PSNR不能准确地给出主观的视频质量值。对于给定的一个图象或一个图象序列来说，高的PSNR通常说明质量高，低PSNR说明质量低。然而，一个特定的PSNR值并不等于绝对的主观的质量。主观上感觉好的图象不一定PSNR值高。这种情况下，人类的观察敏感区中心让人感觉清晰度很好，但信嗓比不一定高。

2.6.2.2 其他的客观质量衡量方法
因为PSNR方法的局限性，最近有很多工作用来开发更加复杂的客观的测试过程，而且表示更准确的主观信息。很多不同的方法都被提出了。但是没有一个可以完全代替主观测试。所以还没有一个比较标准的，准确的，可用的方法。意识到这一点之后，ITU-T视频质量专家组（VQEG）就致力于提出一种客观的视频质量评价机制。每一步就是测试并比较隐藏的模型与测试模型。在2000年三月，VQEG宣布有10个这样的测试系统备选。不幸的是，没有一种被认为是适合的。VQED在2003年进行了第二次的评估。除非非常在自动质量评价中有一个非常大的突破，否则这个问题是很难被解决了。

2.7 结论
采样模拟信号会形成数字视频信号，它有准确，高质量和对于数字媒体的存储传递等各种优势，但是会占用比较在的空间。与生俱来的问题包括空间和时间分辨率，颜色表示和视频质量的测量问题。下一章会介绍视频压缩的一些其他的基本理论.

3.1 介绍
压缩(compress) 动词： 挤压到更小的空间中;即condense
压缩(conpress) 名词： 压缩的行为或是压缩的状态

压缩是把数据用更小的空间来存放的技术.视频压缩(视频编码)是把数字视频流序列用更少的数据位进行存放的方法."Raw"或叫没压缩过的视频需要大量的码(大约每秒信息216M),而且压缩对于数字视频的存储和传输来说都是需要的.

压缩包括一对互补的系统,一个编码器(encoder)和一个解压器(decoder).编码器把原数据在传输或存放之前转变为压缩格式(占用更少的数据位),而解压器把压缩的格式转会到原来的视频数据格式上.编码器/解码器对经常被叫做CODEC(enCOder/DECoder)

数据压缩是通过移除数据冗余来实现的，比如说，对于数据重构过程中无用的数据。很多种数据都有统计上的冗余性，它们就可以通过无损压缩进行有效的压缩，这样的标准比如说JPEG-LS，它可以达到3-4倍的压缩。有损压缩可以达到更高的压缩比。在有损压缩系统中，解压数据与源码流数据是不同的，高压缩率是通过视频质量的下降来达到的。有损视频压缩系统是建立在删除主观冗余的原理之上的，从图象或视频中删掉的部分不会很大程度上影响观察者对于视频质量的认识的。

大多数视频编码方法寻找空间和时间上的冗余来达到压缩的效果。在时间域中，连续几帧的视频通常有很强的相关性，特别是当时域采样率是非常高的时候尤其如止。在空间域中，通常像素采样点之间是相互关联的，比如说，相邻象素之间很相近。

H.264和MPEG4视频标准共用了一部分特征。这两种标准都假设了一种以块(block）为基础的运动补偿，变换，量化和熵编码。我们主要关注到这些主要的方法中，并从时间模型开始，接下来是图象变换，量化，预测式编码和熵编码。并以对于一个图象采样块进行编码和解码的过程进行描述。

3.2 视频编解码器
一个视频编码器器把一个源图像或视频序列转化为一种压缩模式，并在解码器把它构造为源序列的一个拷贝的或是一个近似.如果解压了的视频序列与原序列是相同的，那么编码过程是无损的，如果解压序列与源序列是不同的，那么这个过程是有损的。

CODEC用一种模型来表示原始视频流(一个被有效编码的表示方式，并可以用它来重建视频数据的近似结果或尽量取得高的码率。这两个目标(压缩效率和高质量)通常是相矛盾的，因为一个低的压缩码率通常在解压部分会降低图象的质量。码率和质量的平衡我们会在之后进行介绍

视频编码器是由三个主要的功能部件实现的：时域模型，空域模型和熵编码。时域模型的输入为一个未压缩的视频流序列。时域模型试图用邻近帧的相似性来消除了时域冗余,通常是构造通当前帧的预测。在MPEG4视频部分和H.264中，预测通常从一个或多个之前或之后的帧来进行的，并通过对于帧之间的差别进行补偿。时域模型的输出是一个剩余帧(通过从实际当前帧中减去预测值得到)，而一系列的模型参数，通常是一系列用来描述运动是如何补偿的运动向量。

剩余帧构成了时域模型的输入，它会利用邻近采样点的相似性来降低空域的冗余。在MPEG4视频部分和H.264中，这通常通过一些变换来对样点进行处理来实现。变换把采样点转到其他的域中，在这些域中用变换系数来表示。这些系数被量化来删除不明显的值，只留下很少的大系数来对剩余帧进行表示。空域模型的输出是一系列的量化变换的系数。

时域模型的参数(通常是运动向量)和空域模型的参数(系数)通常用熵编码来进行压缩。这就删除掉了统计上的冗余度(比如，用短二进制码表示当前的向量和系数)并制造出一个压缩流或文件来进行传输或存储。一个压缩的序列由编码的运动向量参数，编码的剩余系数和头信息表示。

视频解吗器从一个压缩流中构造一个视频帧。系数和运动向量由熵解码器进行解码，然后空域模型构建出一个版本的剩余帧。解码器利用运动向量参数与一个或多个解压帧来构成一个对当前帧的预测，然后帧就可以通过加入这个剩余帧来得到。

3.3 时域模型
时域模型的目标是要减少减少传输帧的冗余性。这个过程的输出是一个剩余帧，而且预测过程越准确，剩余帧中包含的能量就越小。剩余帧被编码并送到解压器用来构造预测帧，加上解码的剩余帧来构成当前帧。预测帧是通过一个或多个过去或未来的帧(都叫做参考帧)来创建的。预测的准确性通常可以由参考帧和当前帧之间的运动补偿来改进。

3.3.1 从前一视频帧进行预测
时间域的预测的最简单的方法是从当前帧的前一帧进行预测。用两帧之间的差来做为剩余帧。这个方法的明显的问题在于剩余帧中的能量太多了，这也就是说在时域压缩之后还有大量的数据可以被压缩。大部分的剩余能量是由于在二帧中的物体运动可能造成两帧的运动补偿形成的。

3.3.2 由于运动造成的改变
在视频帧之间的改变可能是由物体的运动造成的(刚性的物体运动，比如说一辆运动着的汽车，或可变形物体运动，比如说移动的手臂），摄象头的移动，被去覆盖的区域(比如说一个运动场景中由于物体的运动致成背景的去覆盖性)和光线的变化。除去去覆盖和光线变化，差别都是由于帧间的像素点的运动造成的。这样构造的像素点的邻接被称为光流(optical flow)。完整的域包括对于每个像素位置的光流向量，但是这些域都是被子采样过的，这样的话，只有每隔两个像素点的向量才被显示出来。

如果光流域是准确描述的，那么它应该可以构成一个对大多数像素点准确的预测，方法即为沿着光流向量移动参考帧中的每个像素点。然而，种种原因之下，这并不是一个实用的运动补偿的方法.对于光流的准确的计算对于计算来说是非常敏感的而且把每个像素点的光流传给解码器也是必要的，以使它能重构造预测帧(这样就得到了大量的传输数据，与我们小剩余值的目标是相矛盾的）。

3.3.3 基于块的运动估计和补偿
一个实用并被广泛使用的运动补偿方法是为了裣一个矩形区域的运动或叫当前帧的“块”。下列的步骤对当前帧的一个M × N采样的块的处理过程：

1. 在参考帧中查找一帧(过去的或以后的，已被编码的或传输的)，来找到一个相匹配的M * N的区域。这是由在查找区域中比较M * N的块,并找到一个最接近这一块的区域。一个流行的匹配方式是用把两个块的能量作差，这样能量相差最小的两个区域被认为是最佳的匹配结果。这个查找匹配的过程被叫做运动估计。

2. 选定的区域成为对于当前M * N块的预测块，它被减掉当前的块来构成一个M*N的剩余块(运动补偿).

3. 剩余块被编码并传输，当前块和选定块的差值(运动向量)也被传输.

解码器使用接收到的运动向量来重建预测区域并解压剩余块，加上之前的预测块来重建一个原始块。

基于块的运动补偿这么流行是有很多原因的。它很直接，计算性上也很易处理，它与矩形视频帧很相适应，并且使用基于块的图形变换(比如DCT等)，而且它对于视频序列提供了一个有很效的时域模型。然而它也有一些缺点，比如说，实际物体中几乎没有平滑的边缘来进行矩形边界的匹配，物体通常在帧之间用很小的像素点位置移动（比如说可变形的物体，旋转和扭曲），而且很多种运动是难以用基于块的方法进行补偿的。尽管它有这些缺点，基于块的运动补偿是当前所有的视频标准使用的时域模型的基础.

3.3.4 对于一个宏块的运动补偿
宏块，对应于一个16*16的帧区域，是大多数编码标准(包括MPEG1,MPEG2,MPEG4,H.261,H.263和H.264)运动补偿预测方法的基本组成部分。对于源4:2:0的视频信号来说，一个对于源帧的16*16像素区域的是由256个亮度采样(用4个8*8的采样块排列)，64个Cb色度采样(用一个8*8的采样块排列),64个Cr色度采样(用一个8*8采样块排列)，这样就一共六个8*8的块。MPEG4或H.264的CODEC通过宏块来处理每一个视频帧.

运动估计
对于一个宏块的运动估计包括在参考帧中找一个与当前宏块相近的16*16的采样区域。参考帧是一个在之前被编码过的帧。参考帧的区域以当前宏块的位置为中心，宏块区域的查找16*16的相匹配区域做为最佳匹配结果。

运动补偿
在参考帧中选定的最佳匹配区域是从当前宏块中减掉的部分，它用来构成一个剩余帧，接着通过运动向量被编码和传输，它也描述了最佳对应区域。在编码器之内，剩余帧被编码和解码并被加到相应区域之中，来重构一个宏块，这个宏块被存为以后的运动补偿预测的参考帧。用一个解码的剩余帧来重构宏块来保证编码器和解码器在运动补偿的时候使用相同的参考帧。

在运动估计和补偿的过程中有很多不同方法。参考帧可以是之前的或之后的一帧，也可以是结合或是更多帧的搭配。。如果一个之后的帧用来进行参考的话，那么就要先对这一帧进行编码。在参考帧和当前帧之间有一个很大的改变的地方（比如说，一个场景的变化），也许不使用运动补偿进行编码宏块会更有效。这样编码器就选择帧内编码(在没有运动补偿的情况下进行编码.在移动场景中移动的物体很少符合16*16像素边缘而且这样也许使用可变的块大小进行运动估计和补偿会更高效。物体可能有很少的像素部分运动，这样使用在参考帧中插值法会是一种更加好的预测方法。

3.3.5 运动补偿块大小
视频序列中的连续两帧中图1是从图2中不通过运动补偿而进行减操作得到的一个剩余帧.剩余帧中的能量由于通过16*16的宏块做运动补偿而降低.每8*8块(而不是16*16)的块会更近一步降低剩余帧中的能量,4*4会更少.这个例子说明了小的运动补偿块可以得到更佳的运动补偿效果.然而,一个更小的运动补偿块会导致复杂度的升高(更多的搜索操作被执行了)，这样更多的运动向量就要被传输。发送每个运动向量需要一些位来做到，这个多余的负担会抵销剩余帧中能量的减少的优势。一个更有效的妥协的方法是采用调节图的块大小，比如说在相似的区域上选择一个大的块,而在高度细节化运动的部分选用更小的块。H.264使用了一种自适应的运动补偿块大小，在以后我们会提到。

3.3.6 子像素运动补偿
一些情况下，通过在参考帧中从插值采样位置来预测会得到更好的运动补偿预测。“子像素”运动估计和补偿包括寻找子采样的插值位置与整值采样位置，来寻找最佳匹配(比如说，最小化剩余帧的能量)并在这个位置使用整或子采样值来直行运动补偿预测。对于四分之一像素运动裣来说，第一步，运动估计会寻找对于整采样格的最佳匹配,接下来编码器在最佳匹配附近寻找半采样位置来看匹配是否可以被改进，如果需要的话，对半采样最佳匹配像素附近的四分之一采样位置进行寻找。最终的匹配（整，子或四分之一采样位置）由当前块或宏块相差得到。

用4*4的块大小得到的剩余帧可以使用半采样插值并有更低的剩余能量。这种方法可以由从四分之一采样格来得到更小的剩余帧能量得到扩展。总体上说，“更好的”插值可以达到更好的运动补偿性能（更小的剩余帧能量），代价则是复杂度会更高一些。这样得到的性能提升会因为插值的步骤的增多而抵销。半采样插值相比整采样有更好的性能，四分之一采样插值会给出更好的效果，八分之一更胜之，以此类推。

一个运动补偿过的参考帧被从当前帧中减去，剩余帧的能量如下（用总绝对误差来近似SAE）：
Sequence No motion compensation  Integer-pel  Half-pel  Quarter-pel
'Violin',QCIF 171945   153475   128320   113744
'Grasses',QCIF 248316   245784   228952   215585
'Carphone',QCIF 102418   73952  56492  47780

一个低的SAE表示更好的运动补偿性能。在每种情况下，子像素运动补偿相对整像素补偿都有更好的性能表现，而四分之一补偿会更好。"Grasses"序列有更复杂的运动，这样就更难以实施运动补偿，悲痛"Violen"和"Carphone"就更容易进行补偿了。

在四分之一采样插值中寻找一个匹配的4*4的块是比在没有插值的16*16的块中更加复杂的。除了更大的复杂度之外，因为每个块的运动向量都要被编码并传输到接收端以更好的重建图象，这样就有了编码上的性能损失了。因为块大小减小了，传输的向量数增加了。需要更多的位来表示半采样或四分之一采样向量，因为向量的更细节部分也必须被像整采样那样进行编码。这样有另复杂运动的补偿模式下就有编码效率上的平衡度了，因为运动补偿越准确，就有更多的数据来表示运动域，但是在不那么准确的情况下，就不需要那么多位了。
3.3.7 基于区域的运动补偿
在一个自然的视频场景中移动的物体很少被对很整齐地对齐到块的边缘，它们很可能是不规则形状的，放置在任意位置上，而且在帧间改变他们的形状。这样就很难在参考帧中找到一个理想的匹配，因为它覆盖了一部分运动着的物体，一部分静态的物体。

在图像的任意区域应用运动补偿是可以达到更好的性能的。比如说，如果我们试图在椭圆形的物体中进行运动补偿的话，我们可以在参考帧中找到一个理想的匹配。然而使用基于区域的运动补偿会遇到很多的实际困难，包括识别区域边界，指出边界的轮廓，在运动补偿之后编码剩余帧，MPEG-4视频包括了一系列的工具来支持基于区域的补偿和编码。

主要注意三个内容：

1. 编译QTE时，在其自定义配置文件（位于QTDIR/src/tools/qconfig-XXX.h，其XXX为自定义的名字，该特征字可以在configure时用-qconfig XXX指定）所应加的内容：

   #define QT_QWS_IPAQ

   #define QT_QWS_IPAQ_RAW

   去掉鼠标自动识别功能 ：#define QT_NO_QWS_MOUSE_AUTO

   去掉不用的鼠标驱动，（在实际中，这一步可以不要，但对于缩减QTE的大小很有帮助），方法主要是在configure时设置配置参数为-no-mouse-pc -no-mouse-bus -no-mouse-yopy -no-mouse-vr41xx 。

   以该编译好的QTE库为基础，编译应用程序；

2. 在目标机上，要将触摸屏驱动链接好。在QTE3.0的版本中，如果定义了上述的两个IPAQ相关的宏，其默认打开设备文件/dev/h3600_tsraw。如果只定义QT_QWS_IPAQ，则打开设备文件为/dev/h3600_ts。

3. 在目标机上，设定环境变量：QWS_MOUSE_PROTO=linuxtp:/dev/h3600_tsraw。

（2）使用tslib方法；

• 编译TSLIB1.3：

  • 进行如下操作

• #./autogen.sh #生成configure文件

• CC= $ARM_TOOL_PATH/arm-linux-gcc

• CXX= $ARM_TOOL_PATH/arm-linux-g++

• ./configure --host=arm-linux --target=arm-linux --disable-inputapi --prefix=$PWD/build

• make

• make install

• 将build的整个目录拷贝到目标机，然后在目标机做如下设定，修改/etc/profile文件，在其中加入以下环境变量的设置

  • export V_ROOT=/xxx/xxx/build #目标机上build所在的路径

  • export TSLIB_TSEVENTTYPE=H3600 #设定类型为H3600，其主要是对着tslib中的设备结构体定义，该定义要与触摸屏驱动中的一致

  • export TSLIB_CONSOLEDEVICE=none #设定控制台设备为none，否则默认为/dev/tty。在tslib1.3源码中，只要不是none，它就会打开$(TSLIB_CONSOLEDEVICE)1，默认的为/dev/tty1的设备，然后从中读取console的可用设置。这样可以避免出现“open consoledevice: No such file or directory KDSETMODE: Bad file descriptor”的错误

  • export TSLIB_FBDEVICE=/dev/fb0 #指定帧缓冲设备

  • export TSLIB_TSDEVICE=/dev/touchscreen/0raw #指定触摸屏设备节点文件

  • export TSLIB_CALIBFILE=$V_ROOT/etc/pointercal #指定触摸屏校准文件pintercal的存放位置

  • export TSLIB_CONFFILE=$V_ROOT/etc/ts.conf #指定TSLIB配置文件的位置

  • export TSLIB_PLUGINDIR=$V_ROOT/share/ts/plugins #指定触摸屏插件所在路径

• 编译TSLIB1.4（TSLIB07072006）

  • 进行如下操作：

    • echo "ac_cv_func_malloc_0_nonnull=yes" > tslib/arm-linux.autogen #为了防止出现undefined reference to `rpl_malloc' 错误

    • CONFIG_SITE=arm-linux.autogen ./configure CC=arm-linux-gcc CXX=arm-linux-g++ --host=arm-s3c2410-linux-gnu --target=arm-s3c2410-linux-gnu --disable-input --disable-arctic2 --disable-mk712 --disable-collie --disable-corgi --disable-ucb1x00 --disable-linear-h2200 --with-gnu-ld --prefix=$PWD/build

    • make

    • make install

  • 将build的整个目录拷贝到目标机，然后在目标机做如下设定，修改/etc/profile文件，在其中加入以下环境变量的设置。其解释类上，不同于TSLIB1.3的是，TLIB1.4通过配置文件ts.conf中module_raw h3600语句来加载对应的设备结构体定义。已废除了TSLIB_TSEVENTTYPE宏。

    • export V_ROOT=/xxx/xxx/build

    • export TSLIB_TSDEVICE=/dev/touchscreen/0raw

    • export TSLIB_CALIBFILE=/etc/pointercal

    • export TSLIB_CONFFILE=$V_ROOT/etc/ts.conf

    • export TSLIB_PLUGINDIR=$V_ROOT/lib/ts

    • export TSLIB_CONSOLEDEVICE=none

    • export TSLIB_FBDEVICE=/dev/fb0

  • 一个值得注意的问题是：TSLIB1.4在ts_config函数中通过while((p=fgets(buf,BUFF_SIZE,f))!=NULL)来加载ts.conf中的语句，而buf只有512byte。所以对于ts.conf没有用的定义语句，请将其删除，以防止误发生段错误。

• 以TSLIB库为基础，编译QTE。

  • QTE2.3.10直接支持-tslib选项开关的应用。不用修改任何文件。可以通过网上所说的拷贝tslib.h头文件及库文件到QTE相关目录来进行编译（对于tslib1.4，还要拷贝tslib_private.h）。也可以在./configure进指定-L<path to tslib library> -I<path to tslib header>来防止出现找不到相应库文件 的错误。（对于tslib1.4，应该还加上-lts选项）。

  • 对于其它版本的QTE，可以通过在QTE文件夹路径下执行grep -lir 'tslib' *来查看是否有对tslib的支持，如果没有则需要对源码进行相应的修改。（onebyte注：虽然网上说有补丁可下，但俺一直没找到相关的patch，但看看QTE2.3.10的源码后再做相应的修改还算比较方便：）

［onebyte后记］：

由于是一个人在做基于embedded linux的软件开发，没有他人直接的交流，所以摸索QTE触摸屏支持的过程是相当辛苦的！网上关于这一块的说法不一，使得自己对QTE触摸屏支持的方法很长时间辨不清方向。但在这里还是要非常感谢网上的许多朋友，正是通过大家的讨论才将这块内容逐渐理通。

在这里特将这些方法记载下来，送给同我一样经历过困惑的朋友们：P

［参考网站］

网上各论坛中关于TSLIB内容的帖子不少，这里只记一些主要的论坛网站，有兴趣的可以到这上面去看看：

[1] 北京理工大学嵌入式linux BBS

[2] 华恒嵌入论坛

[3] Qt中文论坛

[4] QT Forum

[5] China Linux Forum

onebyte注：前一阵子简略地分析了一下QT中触摸屏相关文件，现在把它共享出来。希望能对志同道合的朋友有所帮助：P

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

文件位于QTDIR/src/embedded/文件夹中。

（1）类结构示意图，如下图所示。

（2）与触摸屏相关主要函数进行解释如下：

• QWSLinuxTPMouseHandlerPrivate其构造函数

  在其中打开设备文件/dev/h3600_tsraw或h3600_ts或ts（视宏定义），并将其readMouseData()槽同QSocketNotifier的activated信号连接起来。

  QsocketNotifier由所打开的设备文件号初始化。这样就可以将驱动中的事件同上层应用程序中的鼠标动作联系起来。

• QWSLinuxTPMouseHandlerPrivate::readMouseData()

  该函数读取设备文件/dev/h3600_tsraw或h3600_ts，视宏定义。并在其内部将触摸屏设备坐标（也就是电压值）通过其父类：QWSCalibrateMouseHandler::transform()函数转换为屏幕坐标。并取一定点的平均值。

• QWSCalibrateMouseHandler::transform()

  通过a, b, c, d, e, f转换参数将设备坐标转换为屏幕坐标。

• QWSCalibrateMouseHandler::Calibration()

  求取坐标转换系数及偏差（a, b, c, d, e, f，实际用的是二点校正法：左上及右下点。）。并调用writeCalibration将参数值输出到/etc/pointcal文件中。

• QWSCalibrateMouseHandler::readCalibration()

  从/etc/pointcal文件读取坐标转换系统及偏差。

（3）上述类都是通过qmousedriverfatory进行初始创建的。

［编译环境注：］

宿主机Linux操作系统为Fedro Core 5

交叉编译工具链版本：arm-linux-g++ 2.95.3，

宿主机编译工具链GCC 版本为4.1.0

QT-X11版本为2.3.2

QT/E版本为2.3.7

QTOPIA版本为1.7.0

（1）编译QT-X11

• 解压qt-x11-2.3.2.tar.gz，并更改解压文件夹名为qt-x11

• cd qt-x11

• 更改qt-x11文件夹中src/tools/qvaluestack.h第57行源代码remove( this->fromLast() );为this->remove( this->fromLast() );否则，会出现[xml/qxml.o]错误

• 建立set-env文件

  export QTDIR=$PWD

  export PATH=$QTDIR/bin:$PATH

  export MANPATH=$QTDIR/doc/man:$MANPATH

  export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH

  echo yes | ./configure -no-xft -no-opengl -no-sm

  make

• 在该文件夹下，执"source set-env"命令（.与set-env之间有空格）

（2）编译目标机版本的qte-2.3.7

• 为了编译QTOPIA，将QTOPIA文件夹下./src/qt/qconfig-qpe.h拷贝到QTE文件夹下 src/tools/

• 然后建立set-env文件

  #!/bin/bash

  #编译QTE脚本

  #此处$PWD指的是QTE所在的文件夹

  export QTDIR=$PWD

  export QTEDIR=$QTDIR

  export PATH=$QTDIR/bin:$PATH

  export PATH=/usr/local/arm/2.95.3/bin:$PATH

  export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH

  echo yes | ./configure -platform linux-x86-g++ -xplatform linux-arm-g++ -qconfig qpe -depths 16,24,32

  make

• 执行"source set-env"

• 注意，在此处configure时，一定要写明platform及xplatform，且platform要设为linux-x86-g++，否则当使用linux-generic-g++时，会找当前系统默认的g++，由于前面在PATH处设定新的g++路径，所以会出现错误。

• 如果需要移植到目标机上，则将$QTEDIR/lib/libqte.so.x.y.z拷贝至目标机上lib文件夹下，并命名为/lib/libqte.so.x（根据前面的libqte编号而定）;

  将$QTEDIR/lib/fonts/fontdir拷贝到目标机上qt/e的安装路径上（通过在目标机上设置$QTDIR来实现），如/usr/local/qt-embedded/lib/fonts/fontdir

（3）编译目标机版本的qtopia-1.7.0

• 由于在编译qtopia时，需要用到QTE的uic命令来解释有关的资源，所以此处，需要将前面编译的qt-x11中bin目录下的uic命令拷贝至QTEDIR/bin下。

• 建立set-env文件：

  #!/bin/bash

  #安装QTOPIA

  export QPEDIR=$PWD

  #此处的QTDIR是前面编译的QT/E的路径

  export QTDIR=/friendly-arm/arm-qtopia/qt

  export QTEDIR=$QTDIR

  #本机工具链的位置，根据个人情况设置

  export PATH=/usr/local/arm/2.95.3/bin:$PATH

  export PATH=$QTDIR/bin:$PATH

  export PATH=$QPEDIR/bin:$PATH

  export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH

  cd ./src

  echo yes | ./configure -platform linux-arm-g++

  make

• 执行"source set-env"

• 如果需要移植到目标机上，将QPEDIR目录下的bin, apps, etc, plugins, services, sounds, i18n, lib, pics, help文件夹拷贝到目标机上的QPEDIR处（通过设置QPEDIR来实现）

• 在目标机的bin目录下，建立qtopia脚本文件（如下）

  #!/bin/sh

  export set HOME=/root

  export set QTDIR=/opt/qt

  export set QPEDIR=/opt/qtopia

  export set QWS_KEYBOARD="USB:/dev/input/event1"

  export set QWS_MOUSE_PROTO="USB:/dev/input/mouse0"

  export set PATH=$QPEDIR/bin:$PATH

  export set LD_LIBRARY_PATH=$QTDIR/lib:$QPEDIR/lib

  $QPEDIR/bin/qpe > /dev/null 2>/dev/null

• 在目标机启动后，就可以使用qtopia直接启动

gcc -v ：GCC版本

-c：仅把源代友编译为目标代码；

-s：GCC在为C代码产生了汇编语言文件后，就停止编译。GCC产生的汇编语言文件的缺省扩展名为.s。

-E：指示编译器仅对输入文件进行预处理。此时，预处理器的输出被送到标准输出（如显示器）而不是储存在文件里。

-O：GCC对源码进行基本优化。

-O2：GCC产生尽可能小和尽可能快的代码

-g选项告诉GCC产生能被GNU调试器（如gdb）使用的调试信息，以便调试用户的程序。

-pg选项告诉GCC在用户的程序里加入额外的代码，执行时，产生gporf用的剖析信息以显示程序的耗时情况。

gcc info page：详细GCC编译器参数的说明，在Emacs内，按下C－hi，然后选“gcc”的选项。

2、使用gdb：

gdb filename：能直接指定想要调试的程序。也可用gdb去检查一个因程序异常终止而产生的core文件，或者与一个正在运行的程序相连。

（1）为使gdb正常工作，必须使程序在编译时包含调试信息。调试信息包含程序里的每个变量的类型、在可执行文件里的地址映射以及源代码的行号。

（2）gdb命令一览：

file：装入想要调试的可执行文件

kill：终止正在调试的程序；

list：列出产生执行文件的源代码的一部分

next：执行一行源代码但不进入函数内部；

step：执行一行源代码而且进入函数内部；

run：执行当前被调试的程序；

quit：终止gdb

watch：能监视一个变量的值 而不管它何时被改变；

print：显示表达示的值；

break：在代码里设置断点，这将使程序执行到这里时被挂起；

make：不退出gdb就可以重新产生可执行文件

shell：不离开gdb就执行UNIX shell命令

（3）可在gdb中按Tab键让gdb补齐一个命令。

什么是Socket
　　 Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编程，必须理解Socket接口。
Socket接口设计者最先是将接口放在Unix操作系统里面的。如果了解Unix系统的输入和输出的话，就很容易了解Socket了。网络的 Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket()，该函数返 回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。常用的Socket类型有两种：流式Socket （SOCK_STREAM）和数据报式Socket（SOCK_DGRAM）。流式是一种面向连接的Socket，针对于面向连接的TCP服务应用；数据 报式Socket是一种无连接的Socket，对应于无连接的UDP服务应用。

Socket建立
　　为了建立Socket，程序可以调用Socket函数，该函数返回一个类似于文件描述符的句柄。socket函数原型为：
　　 int socket(int domain, int type, int protocol);
domain指明所使用的协议族，通常为PF_INET，表示互联网协议族（TCP/IP协议族）；type参数指定socket的类型： SOCK_STREAM 或SOCK_DGRAM，Socket接口还定义了原始Socket（SOCK_RAW），允许程序使用低层协议；protocol通常赋值"0"。 Socket()调用返回一个整型socket描述符，你可以在后面的调用使用它。
　　 Socket描述符是一个指向内部数据结构的指针，它指向描述符表入口。调用Socket函数时，socket执行体将建立一个Socket，实际上"建立一个Socket"意味着为一个Socket数据结构分配存储空间。Socket执行体为你管理描述符表。
　　两个网络程序之间的一个网络连接包括五种信息：通信协议、本地协议地址、本地主机端口、远端主机地址和远端协议端口。Socket数据结构中包含这五种信息。

Socket配置
通过socket调用返回一个socket描述符后，在使用socket进行网络传输以前，必须配置该socket。面向连接的socket客户端通过 调用Connect函数在socket数据结构中保存本地和远端信息。无连接socket的客户端和服务端以及面向连接socket的服务端通过调用 bind函数来配置本地信息。
Bind函数将socket与本机上的一个端口相关联，随后你就可以在该端口监听服务请求。Bind函数原型为：
　　 int bind(int sockfd,struct sockaddr *my_addr, int addrlen);
　　 Sockfd是调用socket函数返回的socket描述符,my_addr是一个指向包含有本机IP地址及端口号等信息的sockaddr类型的指针；addrlen常被设置为sizeof(struct sockaddr)。
　　 struct sockaddr结构类型是用来保存socket信息的：
　　 struct sockaddr {
　　 unsigned short sa_family; /* 地址族， AF_xxx */
char sa_data[14]; /* 14 字节的协议地址 */
};
　　 sa_family一般为AF_INET，代表Internet（TCP/IP）地址族；sa_data则包含该socket的IP地址和端口号。
　　 另外还有一种结构类型：
　　 struct sockaddr_in {
　　 short int sin_family; /* 地址族 */
　　 unsigned short int sin_port; /* 端口号 */
　　 struct in_addr sin_addr; /* IP地址 */
　　 unsigned char sin_zero[8]; /* 填充0 以保持与struct sockaddr同样大小 */
　　 };
这个结构更方便使用。sin_zero用来将sockaddr_in结构填充到与struct sockaddr同样的长度，可以用bzero()或memset()函数将其置为零。指向sockaddr_in 的指针和指向sockaddr的指针可以相互转换，这意味着如果一个函数所需参数类型是sockaddr时，你可以在函数调用的时候将一个指向 sockaddr_in的指针转换为指向sockaddr的指针；或者相反。
　　使用bind函数时，可以用下面的赋值实现自动获得本机IP地址和随机获取一个没有被占用的端口号：
　　 my_addr.sin_port = 0; /* 系统随机选择一个未被使用的端口号 */
　　 my_addr.sin_addr.s_addr = INADDR_ANY; /* 填入本机IP地址 */
通过将my_addr.sin_port置为0，函数会自动为你选择一个未占用的端口来使用。同样，通过将my_addr.sin_addr.s_addr置为INADDR_ANY，系统会自动填入本机IP地址。
注意在使用bind函数是需要将sin_port和sin_addr转换成为网络字节优先顺序；而sin_addr则不需要转换。
　　计算机数据存储有两种字节优先顺序：高位字节优先和低位字节优先。Internet上数据以高位字节优先顺序在网络上传输，所以对于在内部是以低位字节优先方式存储数据的机器，在Internet上传输数据时就需要进行转换，否则就会出现数据不一致。
　　 下面是几个字节顺序转换函数：
·htonl()：把32位值从主机字节序转换成网络字节序
·htons()：把16位值从主机字节序转换成网络字节序
·ntohl()：把32位值从网络字节序转换成主机字节序
·ntohs()：把16位值从网络字节序转换成主机字节序
　　 Bind()函数在成功被调用时返回0；出现错误时返回"-1"并将errno置为相应的错误号。需要注意的是，在调用bind函数时一般不要将端口号置为小于1024的值，因为1到1024是保留端口号，你可以选择大于1024中的任何一个没有被占用的端口号。

连接建立
　　面向连接的客户程序使用Connect函数来配置socket并与远端服务器建立一个TCP连接，其函数原型为：
　　 int connect(int sockfd, struct sockaddr *serv_addr,int addrlen);
Sockfd 是socket函数返回的socket描述符；serv_addr是包含远端主机IP地址和端口号的指针；addrlen是远端地质结构的长度。 Connect函数在出现错误时返回-1，并且设置errno为相应的错误码。进行客户端程序设计无须调用bind()，因为这种情况下只需知道目的机器 的IP地址，而客户通过哪个端口与服务器建立连接并不需要关心，socket执行体为你的程序自动选择一个未被占用的端口，并通知你的程序数据什么时候到 打断口。
　　 Connect函数启动和远端主机的直接连接。只有面向连接的客户程序使用socket时才需要将此socket与远端主机相连。无连接协议从不建立直接连接。面向连接的服务器也从不启动一个连接，它只是被动的在协议端口监听客户的请求。
　　 Listen函数使socket处于被动的监听模式，并为该socket建立一个输入数据队列，将到达的服务请求保存在此队列中，直到程序处理它们。
　　 int listen(int sockfd， int backlog);
Sockfd 是Socket系统调用返回的socket 描述符；backlog指定在请求队列中允许的最大请求数，进入的连接请求将在队列中等待accept()它们（参考下文）。Backlog对队列中等待 服务的请求的数目进行了限制，大多数系统缺省值为20。如果一个服务请求到来时，输入队列已满，该socket将拒绝连接请求，客户将收到一个出错信息。
当出现错误时listen函数返回-1，并置相应的errno错误码。
　　 accept()函数让服务器接收客户的连接请求。在建立好输入队列后，服务器就调用accept函数，然后睡眠并等待客户的连接请求。
　　 int accept(int sockfd, void *addr, int *addrlen);
sockfd是被监听的socket描述符，addr通常是一个指向sockaddr_in变量的指针，该变量用来存放提出连接请求服务的主机的信息（某 台主机从某个端口发出该请求）；addrten通常为一个指向值为sizeof(struct sockaddr_in)的整型指针变量。出现错误时accept函数返回-1并置相应的errno值。
　　首先，当accept函数监视的 socket收到连接请求时，socket执行体将建立一个新的socket，执行体将这个新socket和请求连接进程的地址联系起来，收到服务请求的 初始socket仍可以继续在以前的 socket上监听，同时可以在新的socket描述符上进行数据传输操作。

数据传输
　　 Send()和recv()这两个函数用于面向连接的socket上进行数据传输。
　　 Send()函数原型为：
　　 int send(int sockfd, const void *msg, int len, int flags);
Sockfd是你想用来传输数据的socket描述符；msg是一个指向要发送数据的指针；Len是以字节为单位的数据的长度；flags一般情况下置为0（关于该参数的用法可参照man手册）。
　　 Send()函数返回实际上发送出的字节数，可能会少于你希望发送的数据。在程序中应该将send()的返回值与欲发送的字节数进行比较。当send()返回值与len不匹配时，应该对这种情况进行处理。
char *msg = "Hello!";
int len, bytes_sent;
……
len = strlen(msg);
bytes_sent = send(sockfd, msg,len,0);
……
　　 recv()函数原型为：
　　 int recv(int sockfd,void *buf,int len,unsigned int flags);
　　 Sockfd是接受数据的socket描述符；buf 是存放接收数据的缓冲区；len是缓冲的长度。Flags也被置为0。Recv()返回实际上接收的字节数，当出现错误时，返回-1并置相应的errno值。
Sendto()和recvfrom()用于在无连接的数据报socket方式下进行数据传输。由于本地socket并没有与远端机器建立连接，所以在发送数据时应指明目的地址。
sendto()函数原型为：
　　 int sendto(int sockfd, const void *msg,int len,unsigned int flags,const struct sockaddr *to, int tolen);
　　该函数比send()函数多了两个参数，to表示目地机的IP地址和端口号信息，而tolen常常被赋值为sizeof (struct sockaddr)。Sendto 函数也返回实际发送的数据字节长度或在出现发送错误时返回-1。
　　 Recvfrom()函数原型为：
　　 int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr *from,int *fromlen);
from是一个struct sockaddr类型的变量，该变量保存源机的IP地址及端口号。fromlen常置为sizeof (struct sockaddr)。当recvfrom()返回时，fromlen包含实际存入from中的数据字节数。Recvfrom()函数返回接收到的字节数或 当出现错误时返回-1，并置相应的errno。
如果你对数据报socket调用了connect()函数时，你也可以利用send()和recv()进行数据传输，但该socket仍然是数据报socket，并且利用传输层的UDP服务。但在发送或接收数据报时，内核会自动为之加上目地和源地址信息。

结束传输
　　当所有的数据操作结束以后，你可以调用close()函数来释放该socket，从而停止在该socket上的任何数据操作：
close(sockfd);
　　你也可以调用shutdown()函数来关闭该socket。该函数允许你只停止在某个方向上的数据传输，而一个方向上的数据传输继续进行。如你可以关闭某socket的写操作而允许继续在该socket上接受数据，直至读入所有数据。
　　 int shutdown(int sockfd,int how);
　　 Sockfd是需要关闭的socket的描述符。参数 how允许为shutdown操作选择以下几种方式：
　　 ·0-------不允许继续接收数据
　　 ·1-------不允许继续发送数据
　　 ·2-------不允许继续发送和接收数据，
　　 ·均为允许则调用close ()
　　 shutdown在操作成功时返回0，在出现错误时返回-1并置相应errno。

Socket编程实例
　　 代码实例中的服务器通过socket连接向客户端发送字符串"Hello, you are connected!"。只要在服务器上运行该服务器软件，在客户端运行客户软件，客户端就会收到该字符串。
　　 该服务器软件代码如下：
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#define SERVPORT 3333 /*服务器监听端口号 */
#define BACKLOG 10 /* 最大同时连接请求数 */
main()
{
　 int sockfd,client_fd; /*sock_fd：监听socket；client_fd：数据传输socket */
　 struct sockaddr_in my_addr; /* 本机地址信息 */
　 struct sockaddr_in remote_addr; /* 客户端地址信息 */
　 if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
　　 perror("socket创建出错！"); exit(1);
　 }
　 my_addr.sin_family=AF_INET;
　 my_addr.sin_port=htons(SERVPORT);
　 my_addr.sin_addr.s_addr = INADDR_ANY;
　 bzero(&(my_addr.sin_zero),8);
　 if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) {
　 　 perror("bind出错！");
　 　 exit(1);
　 }
　 if (listen(sockfd, BACKLOG) == -1) {
　 　 perror("listen出错！");
　 　 exit(1);
　 }
　 while(1) {
　　 sin_size = sizeof(struct sockaddr_in);
　　 if ((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size)) == -1) {
　 　 　 perror("accept出错");
　 　 　 continue;
　 　}
　　 printf("received a connection from %s\n", inet_ntoa(remote_addr.sin_addr));
　 　if (!fork()) { /* 子进程代码段 */
　　 　 if (send(client_fd, "Hello, you are connected!\n", 26, 0) == -1)
　　 　 perror("send出错！");
　 　 　close(client_fd);
　 　 　exit(0);
　 　}
　　 close(client_fd);
　　 }
　 }
}
服务器的工作流程是这样的：首先调用socket函数创建一个Socket，然后调用bind函数将其与本机地址以及一个本地端口号绑定，然后调用 listen在相应的socket上监听，当accpet接收到一个连接服务请求时，将生成一个新的socket。服务器显示该客户机的IP地址，并通过 新的socket向客户端发送字符串"Hello，you are connected!"。最后关闭该socket。
　　代码实例中的fork()函数生成一个子进程来处理数据传输部分，fork()语句对于子进程返回的值为0。所以包含fork函数的if语句是子进程代码部分，它与if语句后面的父进程代码部分是并发执行的。

客户端程序代码如下：
#include<stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define SERVPORT 3333
#define MAXDATASIZE 100 /*每次最大数据传输量 */
main(int argc, char *argv[]){
　 int sockfd, recvbytes;
　 char buf[MAXDATASIZE];
　 struct hostent *host;
　 struct sockaddr_in serv_addr;
　 if (argc < 2) {
fprintf(stderr,"Please enter the server's hostname!\n");
exit(1);
}
　 if((host=gethostbyname(argv[1]))==NULL) {
herror("gethostbyname出错！");
exit(1);
}
　 if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket创建出错！");
exit(1);
}
　 serv_addr.sin_family=AF_INET;
　 serv_addr.sin_port=htons(SERVPORT);
　 serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
　 bzero(&(serv_addr.sin_zero),8);
　 if (connect(sockfd, (struct sockaddr *)&serv_addr, \
　　 sizeof(struct sockaddr)) == -1) {
perror("connect出错！");
exit(1);
}
　 if ((recvbytes=recv(sockfd, buf, MAXDATASIZE, 0)) ==-1) {
perror("recv出错！");
exit(1);
}
　 buf[recvbytes] = '\0';
　 printf("Received: %s",buf);
　 close(sockfd);
}
　　客户端程序首先通过服务器域名获得服务器的IP地址，然后创建一个socket，调用connect函数与服务器建立连接，连接成功之后接收从服务器发送过来的数据，最后关闭socket。
　　函数gethostbyname()是完成域名转换的。由于IP地址难以记忆和读写，所以为了方便，人们常常用域名来表示主机，这就需要进行域名和IP地址的转换。函数原型为：
　　 struct hostent *gethostbyname(const char *name);
　　 函数返回为hosten的结构类型，它的定义如下：
　　 struct hostent {
　 char *h_name; /* 主机的官方域名 */
　　 char **h_aliases; /* 一个以NULL结尾的主机别名数组 */
　　 int h_addrtype; /* 返回的地址类型，在Internet环境下为AF-INET */
　　 int h_length; /* 地址的字节长度 */
　　 char **h_addr_list; /* 一个以0结尾的数组，包含该主机的所有地址*/
　　 };
　　 #define h_addr h_addr_list[0] /*在h-addr-list中的第一个地址*/
　　 当 gethostname()调用成功时，返回指向struct hosten的指针，当调用失败时返回-1。当调用gethostbyname时，你不能使用perror()函数来输出错误信息，而应该使用herror()函数来输出。

　　无连接的客户/服务器程序的在原理上和连接的客户/服务器是一样的，两者的区别在于无连接的客户/服务器中的客户一般不需要建立连接，而且在发送接收数据时，需要指定远端机的地址。

阻塞和非阻塞
阻塞函数在完成其指定的任务以前不允许程序调用另一个函数。例如，程序执行一个读数据的函数调用时，在此函数完成读操作以前将不会执行下一程序语句。当 服务器运行到accept语句时，而没有客户连接服务请求到来，服务器就会停止在accept语句上等待连接服务请求的到来。这种情况称为阻塞 （blocking）。而非阻塞操作则可以立即完成。比如，如果你希望服务器仅仅注意检查是否有客户在等待连接，有就接受连接，否则就继续做其他事情，则 可以通过将Socket设置为非阻塞方式来实现。非阻塞socket在没有客户在等待时就使accept调用立即返回。
　　 #include <unistd.h>
　　 #include <fcntl.h>
　　 ……
sockfd = socket(AF_INET,SOCK_STREAM,0);
fcntl(sockfd,F_SETFL,O_NONBLOCK)；
……
通过设置socket为非阻塞方式，可以实现"轮询"若干Socket。当企图从一个没有数据等待处理的非阻塞Socket读入数据时，函数将立即返 回，返回值为-1，并置errno值为EWOULDBLOCK。但是这种"轮询"会使CPU处于忙等待方式，从而降低性能，浪费系统资源。而调用 select()会有效地解决这个问题，它允许你把进程本身挂起来，而同时使系统内核监听所要求的一组文件描述符的任何活动，只要确认在任何被监控的文件 描述符上出现活动，select()调用将返回指示该文件描述符已准备好的信息，从而实现了为进程选出随机的变化，而不必由进程本身对输入进行测试而浪费 CPU开销。Select函数原型为:
int select(int numfds,fd_set *readfds,fd_set *writefds，
fd_set *exceptfds,struct timeval *timeout);
其中readfds、writefds、exceptfds分别是被select()监视的读、写和异常处理的文件描述符集合。如果你希望确定是否可以 从标准输入和某个socket描述符读取数据，你只需要将标准输入的文件描述符0和相应的sockdtfd加入到readfds集合中；numfds的值 是需要检查的号码最高的文件描述符加1，这个例子中numfds的值应为sockfd+1；当select返回时，readfds将被修改，指示某个文件 描述符已经准备被读取，你可以通过FD_ISSSET()来测试。为了实现fd_set中对应的文件描述符的设置、复位和测试，它提供了一组宏：
　　 FD_ZERO(fd_set *set)----清除一个文件描述符集；
　　 FD_SET(int fd,fd_set *set)----将一个文件描述符加入文件描述符集中；
　　 FD_CLR(int fd,fd_set *set)----将一个文件描述符从文件描述符集中清除；
　　 FD_ISSET(int fd,fd_set *set)----试判断是否文件描述符被置位。
　　 Timeout参数是一个指向struct timeval类型的指针，它可以使select()在等待timeout长时间后没有文件描述符准备好即返回。struct timeval数据结构为：
　　 struct timeval {
　　 int tv_sec; /* seconds */
　　 int tv_usec; /* microseconds */
};

POP3客户端实例
　　下面的代码实例基于POP3的客户协议，与邮件服务器连接并取回指定用户帐号的邮件。与邮件服务器交互的命令存储在字符串数组POPMessage中，程序通过一个do-while循环依次发送这些命令。
#include<stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define POP3SERVPORT 110
#define MAXDATASIZE 4096

main(int argc, char *argv[]){
int sockfd;
struct hostent *host;
struct sockaddr_in serv_addr;
char *POPMessage[]={
"USER userid\r\n",
"PASS password\r\n",
"STAT\r\n",
"LIST\r\n",
"RETR 1\r\n",
"DELE 1\r\n",
"QUIT\r\n",
NULL
};
int iLength;
int iMsg=0;
int iEnd=0;
char buf[MAXDATASIZE];

if((host=gethostbyname("your.server"))==NULL) {
perror("gethostbyname error");
exit(1);
}
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket error");
exit(1);
}
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(POP3SERVPORT);
serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
bzero(&(serv_addr.sin_zero),8);
if (connect(sockfd, (struct sockaddr *)&serv_addr,sizeof(struct sockaddr))==-1){
perror("connect error");
exit(1);
}

do {
send(sockfd,POPMessage[iMsg],strlen(POPMessage[iMsg]),0);
printf("have sent: %s",POPMessage[iMsg]);

iLength=recv(sockfd,buf+iEnd,sizeof(buf)-iEnd,0);
iEnd+=iLength;
buf[iEnd]='\0';
printf("received: %s,%d\n",buf,iMsg);

iMsg++;
} while (POPMessage[iMsg]);

close(sockfd);
}

Unix/Linux环境下的Socket编程

网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。 Socket也具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该 Socket实现的。常用的Socket类型有两种：流式Socket （SOCK_STREAM）和数据报式Socket（SOCK_DGRAM）。流式是一种面向连接的Socket，针对于面向连接的TCP服务应用；数据 报式Socket是一种无连接的Socket，对应于无连接的UDP服务应用。

    Socket描述符是一个指向内部数据结构的指针，它指向描述符表入口。调用Socket函数时，socket执行体将建立一个Socket，实际上"建立一个Socket"意味着为一个Socket数据结构分配存储空间。Socket执行体为你管理描述符表。两个网络程序之间的一个网络连接包括五种信息：通信协议、本地协议地址、本地主机端口、远端主机地址和远端协议端口。Socket数据结构中包含这五种信息。

   struct sockaddr结构类型是用来保存socket信息的：
    struct sockaddr {
　    unsigned short sa_family; /* 地址族， AF_xxx */ 
        char sa_data[14]; /* 14 字节的协议地址 */
    };
　　sa_family一般为AF_INET，代表Internet（TCP/IP）地址族；sa_data则包含该socket的IP地址和
端口号。
   另外还有一种结构类型：
    struct sockaddr_in {
　　 short int sin_family; /* 地址族 */
　　 unsigned short int sin_port; /* 端口号 */
　　 struct in_addr sin_addr; /* IP地址 */
　　 unsigned char sin_zero[8]; /* 填充0 以保持与struct sockaddr同样大小 */ 
     };

    可以用bzero()或memset()函数将其置为零。指向sockaddr_in 的指针和指向sockaddr的指针可以相
互转换，这意味着如果一个函数所需参数类型是sockaddr时，你可以在函数调用的时候将一个指向
sockaddr_in的指针转换为指向sockaddr的指针；或者相反。

   在使用bind函数是需要将sin_port和sin_addr转换成为网络字节优先顺序；而sin_addr则不需要转换。

   计算机数据存储有两种字节优先顺序：高位字节优先和低位字节优先。Internet上数据以高位字节
优先顺序在网络上传输，所以对于在内部是以低位字节优先方式存储数据的机器，在Internet上传输数
据时就需要进行转换，否则就会出现数据不一致。
　　下面是几个字节顺序转换函数：
·htonl()：把32位值从主机字节序转换成网络字节序
·htons()：把16位值从主机字节序转换成网络字节序
·ntohl()：把32位值从网络字节序转换成主机字节序
·ntohs()：把16位值从网络字节序转换成主机字节序

Bind()函数在成功被调用时返回0；出现错误时返回"-1"并将errno置为相应的错误号。需要注意的
是，在调用bind函数时一般不要将端口号置为小于1024的值，因为1到1024是保留端口号，你可以选择
大于1024中的任何一个没有被占用的端口号。

连接建立
　　面向连接的客户程序使用Connect函数来配置socket并与远端服务器建立一个TCP连接，其函数原型为：int connect(int sockfd, struct sockaddr *serv_addr,int addrlen); Sockfd是socket函数返回的socket描述符；serv_addr是包含远端主机IP地址和端口号的指针；addrlen是远端地址结构的长度。Connect函数在出现错误时返回-1，并且设置errno为相应的错误码。进行客户端程序设计无须调用bind()，因为这种情况下只需知道目的机器的IP地址，而客户通过哪个端口与服务器建立连接并不需要关心，socket执行体为你的程序自动选择一个未被占用的端口，并通知你的程序数据什么时候到打断口。Connect 函数启动和远端主机的直接连接。只有面向连接的客户程序使用socket时才需要将此socket与远端主机相连。无连接协议从不建立直接连接。面向连接 的务器也从不启动一个连接，它只是被动的在协议端口监听客户的请求。                              

        Listen函数使socket处于被动的监听模式，并为该socket建立一个输入数据队列，将到达的服务请求
保存在此队列中，直到程序处理它们。 int listen(int sockfd， int backlog); Sockfd 是Socket系统调用返回的socket 描述符；backlog指定在请求队列中允许的最大请求数，进入的连接请求将在队列中等待accept()它 们（参考下文）。Backlog对队列中等待服务的请求的数目进行了限制，大多数系统缺省值为20。如果一个服务请求到来时，输入队列已满，该 socket将拒绝连接请求，客户将收到一个出错信息。当出现错误时listen函数返回-1，并置相应的errno错误码。

       accept()函数让服务器接收客户的连接请求。在建立好输入队列后，服务器就调用accept函数，然后
睡眠并等待客户的连接请求。int accept(int sockfd, void *addr, int *addrlen); sockfd是被监听的socket描述符，addr通常是一个指向sockaddr_in变量的指针，该变量用来存放提出连接请求服务的主机的信息（某台主机从某个端口发出该请求）；addrlen通常为一个指向值为sizeof(struct sockaddr_in)的整型指针变量。出现错误时accept函数返回-1并置相应的errno值。当accept函数监视的socket收到连接请求时，socket执行体将建立一个新的socket，执行体将这个新socket和请求连接进程的地址联系起来，收到服务请求的初始socket仍可以继续在以前的 socket上监听，同时可以在新的socket描述符上进行数据传输操作。

数据传输 

(面向连接TCP)

       send()和recv()这两个函数用于面向连接的socket上进行数据传输。Send()函数原型为：
　　int send(int sockfd, const void *msg, int len, int flags); Sockfd是你想用来传输数据的socket描述符；msg是一个指向要发送数据的指针；Len是以字节为单位的数据的长度；flags一般情况下置为0。Send()函数返回实际上发送出的字节数，可能会少于你希望发送的数据。在程序中应该将send()的返回值与欲发送的字节数进行比较。当send()返回值与len不匹配时，应该对这种情况进行处理。
　　int recv(int sockfd,void *buf,int len,unsigned int flags); Sockfd是接受数据的socket描述符；buf 是存放接收数据的缓冲区；len是缓冲的长度。Flags也被置为0。Recv()返回实际上接收的字节数，当出现错误时，返回-1并置相应的errno值。

(无连接UDP)

        sendto()和recvfrom()用于在无连接的数据报socket方式下进行数据传输。由于本地socket并没有与远端机器建立连接，所以在发送数据时应指明目的地址。
        int sendto(int sockfd, const void *msg,int len,unsigned int flags,const struct sockaddr *to, int tolen);该函数比send()函数多了两个参数，to表示目地机的IP地址和端口号信息，而tolen常常被赋值为sizeof (struct sockaddr)。sendto函数也返回实际发送的数据字节长度或在出现发送错误时返回-1。

        int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr *from,int *fromlen); from是一个struct sockaddr类型的变量，该变量保存源机的IP地址及端口号。fromlen常置为sizeof (struct sockaddr)。当recvfrom()返回时，fromlen包含实际存入from中的数据字节数。
Recvfrom()函数返回接收到的字节数或当出现错误时返回-1，并置相应的errno。

结束传输

      当所有的数据操作结束以后，你可以调用close()函数来释放该socket，从而停止在该socket上的任
何数据操作：close(sockfd); 也可以调用shutdown()函数来关闭该socket。该函数允许你只停止在某个方向上的数据传输，而一个方向上的数据传输继续进行。如你可以关闭某socket的写操作而允许继续在该socket上接受数据，直至读入所有数据。Sockfd 是需要关闭的socket的描述符。参数 how允许为shutdown操作选择以下几种方式：0-------不允许继续接收数据 1-------不允许继续发送数据 2-------不允许继续发送和接收数据，均为允许则调用close () shutdown在操作成功时返回0，在出现错误时返回-1并置相应errno。

一 . 一般应用
1.const 修饰各种变量的用法 .
   a. 取代 define
     #define D_INT 100
     #define D_LONG 100.29
     ………
     const int D_INT = 100;
     const D_INT = 100;     // 如果定义的 int 类型 , 可省略 int.
     const long D_LONG = 100.29;
     ………
     const int& a = 100;
     const 替代 define 虽然增加分配空间 , 可它却保证了类型安全 .
     在 C 标准中 ,const 定义的数据相当于全局的 , 而 C++ 中视声明的位置而定 .
   b. 修饰指针相关的变量
     以三组简单的定义示意：
     Group1:  
     int a = 0;   
     const int* b = &a;------------  [1]               
     int const *b = &a;------------  [2]                    
     const int* const b = &a;---- [4]  
         
     Group2: 
     const char *p = "const";--------------[1]
     char const *p = "const";--------------[2]  
     char* const p = "const";--------------[3]  
     const char * const p = "const";----[4]     
    
     Group3:
      int a=0;
        const int &b = a;---------------[1]
     int const &b = a;---------------[2] 
     int & const b = a;--------------[3]  //---> 修饰引用时 ,const 被忽略
     const int & const b = a;-----[4]
     总结：
     1. 如果 const 位于星号左侧 , 则 const 用来修饰指针所指向的变量 ,
       即指针指向的为不可变的 .
     2. 如果 const 位于星号右侧 ,const 就是修饰指针本身 , 即指针本身是
       不可变的 .
       因此 ,[1] 和 [2] 的情况相同 , 指针所指向内容不可变 (const 放在变量
       声明符的位置无关 ),
       这种情况下不允许对内容进行更改 , 如不能 *a = 3 ;
     3.[3] 中指针本身是不可变的，而指针所指向的内容是可变的 , 这种情况
       下不能对指针本身
       进行更改操作 , 如 a++ 是错误的
     4.[4] 中指针本身和指向的内容均为常量 .( 引用特殊：引用在使用增加
       遇义时 , 增加它代表的变量 . 所以 qualifiers on reference are ignoredv.
       延伸点 :
       注意示例 :
       1.const int& reference = 1000;
       2.char* p = "const"
         char*& q ;
  
2.const 在函数环境下的各种应用
   常用法示例如下：
   const A&  _Fun(const  A& _in);  // 修饰引用型传入参数
   // A  _Fun(const A& _in);
   //A& _Fun(const A& _in);
   // 上面的两种 , 在函数内部有特殊的步骤 , 这里不详提了… ..
 
   const  A*  _Fun( const  A* _in);   // 修饰指针型传入参数
   void _Fun( ) const;   // 修饰 class 成员函数
   const  A&  _Fun(A& _in );  // 修饰返回值
   const A & operator(const A& _in);  // 同时修饰传入参数和返回值

   a. 修饰参数
     如 void _Fun(const A* _in) 或 void _Fun(const A& _in);
     它们被修饰后 , 在函数执行期间行为特性同于上面的讲解 ,
     注意：这不会改变原来数据的是否是 const 的属性 .

   b. 修饰函数返回值
    const A&  _Fun( )
    const A*   _Fun( );
    注意：由于生命期不同步的问题 , 不可将局部的变量的指针或引用返回 (static 除外 ).
    另外 , 传出来的视情况 , 代表不同的意思…
    对于 A& 返回类型 , 你若将之赋与其它变量 , 那么它实际执行的是将返回的变量
    ( 或引用 ) 代表的数据赋出 .. 而你若将其它值赋予之 , 那么被赋予的是变量或引
    用代表的数据 . 而 const A& 一般是防止之做为左值被赋值 .

    这个地方还有很多的细节问题 ( 譬如在连续赋值、返回的临时对象的处理、
    重载的 const 和非 cosnt 运算符等等 ), 读者自己在实践中需要多多总结 .

二、难点
3. 修饰类成员函数的 const.
   形如 :void _Fun() const { };
   你需要知道的几点规则：

   a.const 对象只能访问 const 成员函数 , 而非 const 对象可以访问任意
     的成员函数 , 包括 const 成员函数 .
   b.const 对象的成员是不可修改的 , 然而 const 对象通过指针维护的对象却
     是可以修改的 .
   c.const 成员函数不可以修改对象的数据 , 不管对象是否具有 const 性质 . 它在
     编译时 , 以是否修改成员数据为依据 , 进行检查 .
   e. 然而加上 mutable 修饰符的数据成员 , 对于任何情况下通过任何手段
     都可修改 , 自然此时的 const 成员函数是可以修改它的…

4. 谈谈 volatile 和”完全 const 对象”
  一个有 volatile 修饰的类只允许访问其接口的一个子集，这个子集由类的
  实现者来控制 . 用户只有用 const_cast 才可以访问这个类型的全部接口 . 而且 ,
  象 const 一样，类的 volatile 属性会传递给它的成员 . 想象 const 修饰的对
  象 , 它的成员变量是不可修改的 , 而它通过指针维护的对象或原生变量是可
  修改 . 那么我们想 : 如果对象维护一个 char* , 则它相当于 char*
  const chrptr ; 而不是 const char* cosnt chrptr; 对于类中的指针你需要
  这样修饰以防止它或它维护的资源： cosnt x* xptr; 而不是 x*const xptr;
  因为 cosnt 修饰的对象它默认 的行为是延续变量： x* cosnt xptr;

  更重要的 ,volatile 修饰的数据 , 编译器不可对其进行执行期寄存于寄存器的优化 .
  这种特性 , 是为了多线程同步的需要 . 有兴趣者看参看 Andrei 的 GP 系列文章 .

5. 谈谈 const_cast 转换运算符
  这个关键字最基础的用法是：去掉数据的 const 性质 .
  值得注意的是：它只对指针、引用和其它的具有指向性质的类型 .

参考：
    1. 《 Effective C++ 》关于 const 两种语义的论述
    2.Andrei Alexandrescu 《 volatile ——编写多线程程序的好帮手》

　　首先摘录一段文字，来源《UNIX Programming FAQ 中文版》
 
1.14. 我怎样找到进程的相应可执行文件？
　　这个问题可以作为'常见未回答问题'('Frequently Unanswered Questions')的一个好候选，因为事实上提出这个问题经常意味着程序的设计有缺陷。:)
　　你能作的'最佳猜测'('best guess')是通过审视'argv[0]'的值而获得。如果它包括一个'/'，那么它可能是可执行程序的绝对或相对(对于在程序开始时的当前目录而言) 路径。如果不包括，那么你可以仿效shell对于'PATH'变量的查询来查找这个程序。但是，不能保证成功，因为有可能执行程序时'argv[0]'是一些任意值，也不排除这个可执行文件在执行后可能已经被更名或删除的情况。
　　如果所有你想做的只是能打印一个和错误消息一起出现的合适的名字，那么最好的方法在'main()'函数中将'argv[0]'的值保存在全局变量中以供整个程序使用。虽然没有保证说'argv[0]'的值总是有意义，但在大多数情况下它是最好的选择。
　　人们询问这个问题的最普通原因是意图定位他们程序的配置文件。这被认为是不好的形式；包含可执行文件的目录应当*只*包含可执行文件，而且基于管理的要求经常试图将配置文件放置在和可执行文件不同的文件系统。
　　试图做这个的一个比较不普通但更正规的理由是允许程序调用'exec()'执行它自己；这是一种用来完全重新初始化进程(比如被用于一些'sendmail'的版本)的办法(比如当一个守护程序捕获一个'SIGHUP'信号)。

　　完全同意上面的观点的！所以并不建议在Linux下去实现GetModuleFileName，不过出于技术的角度，讨论一下这个问题也是可以的。
 
　　好，下面说说茴字的四种写法。哦，不，是GetModuleFileName的四种写法。

GetModuleFileName的四种写法

方法一：从PATH入手
说明：上文提供的思路

int GetModuleFileName1( char* sModuleName, char* sFileName, int nSize)
{
 int ret = -1;
 if( strchr( sModuleName,'/' ) != NULL )
  strcpy( sFileName, sModuleName );
 else
 {
  char* sPath = getenv("PATH");
  char* pHead = sPath;
  char* pTail = NULL;
  while( pHead != NULL && *pHead != '\x0' )
  {
   pTail = strchr( pHead, ':' );
   if( pTail != NULL )
   {
    strncpy( sFileName, pHead, pTail-pHead );
    sFileName[pTail-pHead] = '\x0';
    pHead = pTail+1;
   }
   else
   {
    strcpy( sFileName, pHead );
    pHead = NULL;
   }
   
   int nLen = strlen(sFileName);
   if( sFileName[nLen] != '/' )sFileName[nLen] = '/';
   strcpy( sFileName+nLen+1,sModuleName);
   if( 0 == access( sFileName, F_OK ) )
   {
    ret = 0;
    break;
   }
  }
 }
 return ret;
}

方法二：利用which命令
说明：  与方法一相比，完全是换汤不换药，之所以放在这里，是因为其中用到了一个小技巧：即利用popen()实现在代码中执行一段command，并得到其执行的结果。
       
int GetModuleFileName2( char* sModuleName, char* sFileName, int nSize)
{
 int ret = 0;
 if( strchr( sModuleName,'/' ) != NULL )
  strcpy( sFileName, sModuleName );
 else
 {
  char sBuffer[256] = { 0, };
  char sCommand[256] = { 0, };
  FILE* fp = NULL;
  sprintf( sCommand, "which %s", sModuleName );
  if((fp = popen(sCommand,"r")) == NULL){
   ret = -1;
  }   
  else
  {
   sFileName[0] = '\x0';
   while(!feof(fp)){
    if(fgets(sBuffer,nSize-1,fp) == NULL){
     continue;
    }
    strcat( sFileName, sBuffer );
   }
  }
     int nLen = strlen( sFileName );
  if( 0 == nLen )
   ret = -1;
  else
   if( sFileName[nLen-1] = '\n' ) sFileName[nLen-1] = '\x0';
 }
 return ret;
}

方法二：获取环境变量"_"

int GetModuleFileName3( char* sModuleName, char* sFileName, int nSize)
{
 int ret = -1;
    char* p = getenv("_");
 if( p != NULL && strstr( p, sModuleName ) != NULL )
 {
  ret = 0;
  strcpy( sFileName, p );
 }
 return ret;
}

方法四：读取/proc/self/maps
说明：  细节请参阅 http://autopackage.org/docs/binreloc/
int GetModuleFileName4( char* sModuleName, char* sFileName, int nSize)
{
 int ret = -1;
 char sLine[1024] = { 0 };
 void* pSymbol = (void*)"";
 FILE *fp;
 char *pPath;

 fp = fopen ("/proc/self/maps", "r");
 if ( fp != NULL )
 {
  while (!feof (fp))
  {
   unsigned long start, end;

   if ( !fgets (sLine, sizeof (sLine), fp))
    continue;
   if ( !strstr (sLine, " r-xp ") || !strchr (sLine, '/'))
    continue;

   sscanf (sLine, "%lx-%lx ", &start, &end);
   if (pSymbol >= (void *) start && pSymbol < (void *) end)
   {
    char *tmp;
    size_t len;

    /* Extract the filename; it is always an absolute path */
    pPath = strchr (sLine, '/');

    /* Get rid of the newline */
    tmp = strrchr (pPath, '\n');
    if (tmp) *tmp = 0;

    /* Get rid of "(deleted)" */
    //len = strlen (pPath);
    //if (len > 10 && strc

(1)message 参数。 Message 参数是我最喜欢的一个参数，它能够在编译信息输出窗
口中输出相应的信息，这对于源代码信息的控制是非常重要的。其使用方法为：
#Pragma message(“消息文本”)
当编译器遇到这条指令时就在编译输出窗口中将消息文本打印出来。
当我们在程序中定义了许多宏来控制源代码版本的时候，我们自己有可能都会忘记有没有正
确的设置这些宏，此时我们可以用这条指令在编译的时候就进行检查。假设我们希望判断自
己有没有在源代码的什么地方定义了_X86这个宏可以用下面的方法
#ifdef _X86
#Pragma message(“_X86 macro activated!”)
#endif
当我们定义了_X86这个宏以后，应用程序在编译时就会在编译输出窗口里显示“_
X86 macro activated!”。我们就不会因为不记得自己定义的一些特定的宏而抓耳挠腮了
。

(2)另一个使用得比较多的pragma参数是code_seg。格式如：
#pragma code_seg( ["section-name"[,"section-class"] ] )
它能够设置程序中函数代码存放的代码段，当我们开发驱动程序的时候就会使用到它。

(3)#pragma once (比较常用）
只要在头文件的最开始加入这条指令就能够保证头文件被编译一次，这条指令实际上在VC6(6)#pragma warning( disable : 4507 34; once : 4385; error : 164 )
等价于：
#pragma warning(disable:4507 34) // 不显示4507和34号警告信息
#pragma warning(once:4385) // 4385号警告信息仅报告一次
#pragma warning(error:164) // 把164号警告信息作为一个错误。
同时这个pragma warning 也支持如下格式：
#pragma warning( push [ ,n ] )
#pragma warning( pop )
这里n代表一个警告等级(1---4)。
#pragma warning( push )保存所有警告信息的现有的警告状态。
#pragma warning( push, n)保存所有警告信息的现有的警告状态，并且把全局警告
等级设定为n。
#pragma warning( pop )向栈中弹出最后一个警告信息，在入栈和出栈之间所作的
一切改动取消。例如：
#pragma warning( push )
#pragma warning( disable : 4705 )
#pragma warning( disable : 4706 )
#pragma warning( disable : 4707 )
//.......
#pragma warning( pop )
在这段代码的最后，重新保存所有的警告信息(包括4705，4706和4707)。
（7）pragma comment(...)
该指令将一个注释记录放入一个对象文件或可执行文件中。
常用的lib关键字，可以帮我们连入一个库文件。

补充一个 #pragma pack 1 将c/c++结构体里面的数据按照1字节对齐。这条指令在通信的时
候很常用

GDB概述
————

GDB 是GNU开源组织发布的一个强大的UNIX下的程序调试工具。或许，各位比较喜欢那种图形界面方式的，像VC、BCB等IDE的调试，但如果你是在 UNIX平台下做软件，你会发现GDB这个调试工具有比VC、BCB的图形化调试器更强大的功能。所谓“寸有所长，尺有所短”就是这个道理。

一般来说，GDB主要帮忙你完成下面四个方面的功能：

    1、启动你的程序，可以按照你的自定义的要求随心所欲的运行程序。
    2、可让被调试的程序在你所指定的调置的断点处停住。（断点可以是条件表达式）
    3、当程序被停住时，可以检查此时你的程序中所发生的事。
    4、动态的改变你程序的执行环境。

从上面看来，GDB和一般的调试工具没有什么两样，基本上也是完成这些功能，不过在细节上，你会发现GDB这个调试工具的强大，大家可能比较习惯了图形化的调试工具，但有时候，命令行的调试工具却有着图形化工具所不能完成的功能。让我们一一看来。

一个调试示例
——————

源程序：tst.c

     1 #include <stdio.h>
     2
     3 int func(int n)
     4 {
     5         int sum=0,i;
     6         for(i=0; i<n; i++)
     7         {
     8                 sum+=i;
     9         }
    10         return sum;
    11 }
    12
    13
    14 main()
    15 {
    16         int i;
    17         long result = 0;
    18         for(i=1; i<=100; i++)
    19         {
    20                 result += i;
    21         }
    22
    23        printf("result[1-100] = %d \n", result );
    24        printf("result[1-250] = %d \n", func(250) );
    25 }

编译生成执行文件：（Linux下）
    hchen/test> cc -g tst.c -o tst

使用GDB调试：

hchen/test> gdb tst  <---------- 启动GDB
GNU gdb 5.1.1
Copyright 2002 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB.  Type "show warranty" for details.
This GDB was configured as "i386-suse-linux"...
(gdb) l     <-------------------- l命令相当于list，从第一行开始例出原码。
1        #include <stdio.h>
2
3        int func(int n)
4        {
5                int sum=0,i;
6                for(i=0; i<n; i++)
7                {
8                        sum+=i;
9                }
10               return sum;
(gdb)       <-------------------- 直接回车表示，重复上一次命令
11       }
12
13
14       main()
15       {
16               int i;
17               long result = 0;
18               for(i=1; i<=100; i++)
19               {
20                       result += i;   
(gdb) break 16    <-------------------- 设置断点，在源程序第16行处。
Breakpoint 1 at 0x8048496: file tst.c, line 16.
(gdb) break func  <-------------------- 设置断点，在函数func()入口处。
Breakpoint 2 at 0x8048456: file tst.c, line 5.
(gdb) info break  <-------------------- 查看断点信息。
Num Type           Disp Enb Address    What
1   breakpoint     keep y   0x08048496 in main at tst.c:16
2   breakpoint     keep y   0x08048456 in func at tst.c:5
(gdb) r           <--------------------- 运行程序，run命令简写
Starting program: /home/hchen/test/tst

Breakpoint 1, main () at tst.c:17    <---------- 在断点处停住。
17               long result = 0;
(gdb) n          <--------------------- 单条语句执行，next命令简写。
18               for(i=1; i<=100; i++)
(gdb) n
20                       result += i;
(gdb) n
18               for(i=1; i<=100; i++)
(gdb) n
20                       result += i;
(gdb) c          <--------------------- 继续运行程序，continue命令简写。
Continuing.
result[1-100] = 5050       <----------程序输出。

Breakpoint 2, func (n=250) at tst.c:5
5                int sum=0,i;
(gdb) n
6                for(i=1; i<=n; i++)
(gdb) p i        <--------------------- 打印变量i的值，print命令简写。
$1 = 134513808
(gdb) n
8                        sum+=i;
(gdb) n
6                for(i=1; i<=n; i++)
(gdb) p sum
$2 = 1
(gdb) n
8                        sum+=i;
(gdb) p i
$3 = 2
(gdb) n
6                for(i=1; i<=n; i++)
(gdb) p sum
$4 = 3
(gdb) bt        <--------------------- 查看函数堆栈。
#0  func (n=250) at tst.c:5
#1  0x080484e4 in main () at tst.c:24
#2  0x400409ed in __libc_start_main () from /lib/libc.so.6
(gdb) finish    <--------------------- 退出函数。
Run till exit from #0  func (n=250) at tst.c:5
0x080484e4 in main () at tst.c:24
24              printf("result[1-250] = %d \n", func(250) );
Value returned is $6 = 31375
(gdb) c     <--------------------- 继续运行。
Continuing.
result[1-250] = 31375    <----------程序输出。

Program exited with code 027. <--------程序退出，调试结束。
(gdb) q     <--------------------- 退出gdb。
hchen/test>

好了，有了以上的感性认识，还是让我们来系统地认识一下gdb吧。

使用GDB
————

一般来说GDB主要调试的是C/C++的程序。要调试C/C++的程序，首先在编译时，我们必须要把调试信息加到可执行文件中。使用编译器（cc/gcc/g++）的 -g 参数可以做到这一点。如：

    > cc -g hello.c -o hello
    > g++ -g hello.cpp -o hello

如果没有-g，你将看不见程序的函数名、变量名，所代替的全是运行时的内存地址。当你用-g把调试信息加入之后，并成功编译目标代码以后，让我们来看看如何用gdb来调试他。

启动GDB的方法有以下几种：

    1、gdb <program>
       program也就是你的执行文件，一般在当然目录下。

    2、gdb <program> core
       用gdb同时调试一个运行程序和core文件，core是程序非法执行后core dump后产生的文件。

    3、gdb <program> <PID>
       如果你的程序是一个服务程序，那么你可以指定这个服务程序运行时的进程ID。gdb会自动attach上去，并调试他。program应该在PATH环境变量中搜索得到。

GDB启动时，可以加上一些GDB的启动开关，详细的开关可以用gdb -help查看。我在下面只例举一些比较常用的参数：

    -symbols <file>
    -s <file>
    从指定文件中读取符号表。

    -se file
    从指定文件中读取符号表信息，并把他用在可执行文件中。

    -core <file>
    -c <file>
    调试时core dump的core文件。

    -directory <directory>
    -d <directory>
    加入一个源文件的搜索路径。默认搜索路径是环境变量中PATH所定义的路径。

GDB的命令概貌
———————

启动gdb后，就你被带入gdb的调试环境中，就可以使用gdb的命令开始调试程序了，gdb的命令可以使用help命令来查看，如下所示：

    /home/hchen> gdb
    GNU gdb 5.1.1
    Copyright 2002 Free Software Foundation, Inc.
    GDB is free software, covered by the GNU General Public License, and you are
    welcome to change it and/or distribute copies of it under certain conditions.
    Type "show copying" to see the conditions.
    There is absolutely no warranty for GDB.  Type "show warranty" for details.
    This GDB was configured as "i386-suse-linux".
    (gdb) help
    List of classes of commands:

    aliases -- Aliases of other commands
    breakpoints -- Making program stop at certain points
    data -- Examining data
    files -- Specifying and examining files
    internals -- Maintenance commands
    obscure -- Obscure features
    running -- Running the program
    stack -- Examining the stack
    status -- Status inquiries
    support -- Support facilities
    tracepoints -- Tracing of program execution without stopping the program
    user-defined -- User-defined commands

    Type "help" followed by a class name for a list of commands in that class.
    Type "help" followed by command name for full documentation.
    Command name abbreviations are allowed if unambiguous.
    (gdb)

gdb 的命令很多，gdb把之分成许多个种类。help命令只是例出gdb的命令种类，如果要看种类中的命令，可以使用help <class> 命令，如：help breakpoints，查看设置断点的所有命令。也可以直接help <command>来查看命令的帮助。

gdb中，输入命令时，可以不用打全命令，只用打命令的前几个字符就可以了，当然，命令的前几个字符应该要标志着一个唯一的命令，在Linux下，你可以敲击两次TAB键来补齐命令的全称，如果有重复的，那么gdb会把其例出来。
   
    示例一：在进入函数func时，设置一个断点。可以敲入break func，或是直接就是b func
    (gdb) b func
    Breakpoint 1 at 0x8048458: file hello.c, line 10.
 
    示例二：敲入b按两次TAB键，你会看到所有b打头的命令：
    (gdb) b
    backtrace  break      bt
    (gdb)

    示例三：只记得函数的前缀，可以这样：
    (gdb) b make_ <按TAB键>
    （再按下一次TAB键，你会看到:）
    make_a_section_from_file     make_environ
    make_abs_section             make_function_type
    make_blockvector             make_pointer_type
    make_cleanup                 make_reference_type
    make_command                 make_symbol_completion_list
    (gdb) b make_
    GDB把所有make开头的函数全部例出来给你查看。

    示例四：调试C++的程序时，有可以函数名一样。如：
    (gdb) b 'bubble( M-?
    bubble(double,double)    bubble(int,int)
    (gdb) b 'bubble(
    你可以查看到C++中的所有的重载函数及参数。（注：M-?和“按两次TAB键”是一个意思）

要退出gdb时，只用发quit或命令简称q就行了。

GDB中运行UNIX的shell程序
————————————

在gdb环境中，你可以执行UNIX的shell的命令，使用gdb的shell命令来完成：

    shell <command string>
    调用UNIX的shell来执行<command string>，环境变量SHELL中定义的UNIX的shell将会被用来执行<command string>，如果SHELL没有定义，那就使用UNIX的标准shell：/bin/sh。（在Windows中使用Command.com或 cmd.exe）

还有一个gdb命令是make：
    make <make-args>
    可以在gdb中执行make命令来重新build自己的程序。这个命令等价于“shell make <make-args>”。

在GDB中运行程序
————————

当以gdb <program>方式启动gdb后，gdb会在PATH路径和当前目录中搜索<program>的源文件。如要确认gdb是否读到源文件，可使用l或list命令，看看gdb是否能列出源代码。

在gdb中，运行程序使用r或是run命令。程序的运行，你有可能需要设置下面四方面的事。

1、程序运行参数。
    set args 可指定运行时参数。（如：set args 10 20 30 40 50）
    show args 命令可以查看设置好的运行参数。

2、运行环境。
    path <dir> 可设定程序的运行路径。
    show paths 查看程序的运行路径。
    set environment varname [=value] 设置环境变量。如：set env USER=hchen
    show environment [varname] 查看环境变量。

3、工作目录。
    cd <dir> 相当于shell的cd命令。
    pwd 显示当前的所在目录。

4、程序的输入输出。
    info terminal 显示你程序用到的终端的模式。
    使用重定向控制程序输出。如：run > outfile
    tty命令可以指写输入输出的终端设备。如：tty /dev/ttyb

调试已运行的程序
————————

两种方法：
1、在UNIX下用ps查看正在运行的程序的PID（进程ID），然后用gdb <program> PID格式挂接正在运行的程序。
2、先用gdb <program>关联上源代码，并进行gdb，在gdb中用attach命令来挂接进程的PID。并用detach来取消挂接的进程。

暂停 / 恢复程序运行
—————————

调试程序中，暂停程序运行是必须的，GDB可以方便地暂停程序的运行。你可以设置程序的在哪行停住，在什么条件下停住，在收到什么信号时停往等等。以便于你查看运行时的变量，以及运行时的流程。

当进程被gdb停住时，你可以使用info program 来查看程序的是否在运行，进程号，被暂停的原因。

在gdb中，我们可以有以下几种暂停方式：断点（BreakPoint）、观察点（WatchPoint）、捕捉点（CatchPoint）、信号（Signals）、线程停止（Thread Stops）。如果要恢复程序运行，可以使用c或是continue命令。

一、设置断点（BreakPoint）
   
    我们用break命令来设置断点。正面有几点设置断点的方法：
   
    break <function>
        在进入指定函数时停住。C++中可以使用class::function或function(type,type)格式来指定函数名。

    break <linenum>
        在指定行号停住。

    break +offset
    break -offset
        在当前行号的前面或后面的offset行停住。offiset为自然数。

    break filename:linenum
        在源文件filename的linenum行处停住。

    break filename:function
        在源文件filename的function函数的入口处停住。

    break *address
        在程序运行的内存地址处停住。

    break
        break命令没有参数时，表示在下一条指令处停住。

    break ... if <condition>
        ...可以是上述的参数，condition表示条件，在条件成立时停住。比如在循环境体中，可以设置break if i=100，表示当i为100时停住程序。

    查看断点时，可使用info命令，如下所示：（注：n表示断点号）
    info breakpoints [n]
    info break [n]
   

二、设置观察点（WatchPoint）
   
    观察点一般来观察某个表达式（变量也是一种表达式）的值是否有变化了，如果有变化，马上停住程序。我们有下面的几种方法来设置观察点：
   
    watch <expr>
        为表达式（变量）expr设置一个观察点。一量表达式值有变化时，马上停住程序。
       
    rwatch <expr>
        当表达式（变量）expr被读时，停住程序。
       
    awatch <expr>
        当表达式（变量）的值被读或被写时，停住程序。
   
    info watchpoints
        列出当前所设置了的所有观察点。

三、设置捕捉点（CatchPoint）

    你可设置捕捉点来补捉程序运行时的一些事件。如：载入共享库（动态链接库）或是C++的异常。设置捕捉点的格式为：
   
    catch <event>
        当event发生时，停住程序。event可以是下面的内容：
        1、throw 一个C++抛出的异常。（throw为关键字）
        2、catch 一个C++捕捉到的异常。（catch为关键字）
        3、exec 调用系统调用exec时。（exec为关键字，目前此功能只在HP-UX下有用）
        4、fork 调用系统调用fork时。（fork为关键字，目前此功能只在HP-UX下有用）
        5、vfork 调用系统调用vfork时。（vfork为关键字，目前此功能只在HP-UX下有用）
        6、load 或 load <libname> 载入共享库（动态链接库）时。（load为关键字，目前此功能只在HP-UX下有用）
        7、unload 或 unload <libname> 卸载共享库（动态链接库）时。（unload为关键字，目前此功能只在HP-UX下有用）

    tcatch <event>
        只设置一次捕捉点，当程序停住以后，应点被自动删除。

四、维护停止点

上面说了如何设置程序的停止点，GDB中的停止点也就是上述的三类。在GDB中，如果你觉得已定义好的停止点没有用了，你可以使用delete、clear、disable、enable这几个命令来进行维护。

    clear
        清除所有的已定义的停止点。

    clear <function>
    clear <filename:function>
        清除所有设置在函数上的停止点。

    clear <linenum>
    clear <filename:linenum>
        清除所有设置在指定行上的停止点。

    delete [breakpoints] [range...]
        删除指定的断点，breakpoints为断点号。如果不指定断点号，则表示删除所有的断点。range 表示断点号的范围（如：3-7）。其简写命令为d。

比删除更好的一种方法是disable停止点，disable了的停止点，GDB不会删除，当你还需要时，enable即可，就好像回收站一样。

    disable [breakpoints] [range...]
        disable所指定的停止点，breakpoints为停止点号。如果什么都不指定，表示disable所有的停止点。简写命令是dis.

    enable [breakpoints] [range...]
        enable所指定的停止点，breakpoints为停止点号。

    enable [breakpoints] once range...
        enable所指定的停止点一次，当程序停止后，该停止点马上被GDB自动disable。

    enable [breakpoints] delete range...
        enable所指定的停止点一次，当程序停止后，该停止点马上被GDB自动删除。

五、停止条件维护

前面在说到设置断点时，我们提到过可以设置一个条件，当条件成立时，程序自动停止，这是一个非常强大的功能，这里，我想专门说说这个条件的相关维护命令。一般来说，为断点设置一个条件，我们使用if关键词，后面跟其断点条件。并且，条件设置好后，我们可以用condition命令来修改断点的条件。（只有 break和watch命令支持if，catch目前暂不支持if）

    condition <bnum> <expression>
        修改断点号为bnum的停止条件为expression。

    condition <bnum>
        清除断点号为bnum的停止条件。

还有一个比较特殊的维护命令ignore，你可以指定程序运行时，忽略停止条件几次。

    ignore <bnum> <count>
        表示忽略断点号为bnum的停止条件count次。

六、为停止点设定运行命令

我们可以使用GDB提供的command命令来设置停止点的运行命令。也就是说，当运行的程序在被停止住时，我们可以让其自动运行一些别的命令，这很有利行自动化调试。对基于GDB的自动化调试是一个强大的支持。

    commands [bnum]
    ... command-list ...
    end

    为断点号bnum指写一个命令列表。当程序被该断点停住时，gdb会依次运行命令列表中的命令。

    例如：

        break foo if x>0
        commands
        printf "x is %d\n",x
        continue
        end
        断点设置在函数foo中，断点条件是x>0，如果程序被断住后，也就是，一旦x的值在foo函数中大于0，GDB会自动打印出x的值，并继续运行程序。

如果你要清除断点上的命令序列，那么只要简单的执行一下commands命令，并直接在打个end就行了。

七、断点菜单

在C ++中，可能会重复出现同一个名字的函数若干次（函数重载），在这种情况下，break <function>不能告诉GDB要停在哪个函数的入口。当然，你可以使用break <function(type)>也就是把函数的参数类型告诉GDB，以指定一个函数。否则的话，GDB会给你列出一个断点菜单供你选择你所需要的断点。你只要输入你菜单列表中的编号就可以了。如：

    (gdb) b String::after
    [0] cancel
    [1] all
    [2] file:String.cc; line number:867
    [3] file:String.cc; line number:860
    [4] file:String.cc; line number:875
    [5] file:String.cc; line number:853
    [6] file:String.cc; line number:846
    [7] file:String.cc; line number:735
    > 2 4 6
    Breakpoint 1 at 0xb26c: file String.cc, line 867.
    Breakpoint 2 at 0xb344: file String.cc, line 875.
    Breakpoint 3 at 0xafcc: file String.cc, line 846.
    Multiple breakpoints were set.
    Use the "delete" command to delete unwanted
     breakpoints.
    (gdb)

可见，GDB列出了所有after的重载函数，你可以选一下列表编号就行了。0表示放弃设置断点，1表示所有函数都设置断点。

八、恢复程序运行和单步调试

当程序被停住了，你可以用continue命令恢复程序的运行直到程序结束，或下一个断点到来。也可以使用step或next命令单步跟踪程序。

    continue [ignore-count]
    c [ignore-count]
    fg [ignore-count]
        恢复程序运行，直到程序结束，或是下一个断点到来。ignore-count表示忽略其后的断点次数。continue，c，fg三个命令都是一样的意思。

    step <count>
        单步跟踪，如果有函数调用，他会进入该函数。进入函数的前提是，此函数被编译有debug信息。很像VC等工具中的step in。后面可以加count也可以不加，不加表示一条条地执行，加表示执行后面的count条指令，然后再停住。

    next <count>
        同样单步跟踪，如果有函数调用，他不会进入该函数。很像VC等工具中的step over。后面可以加count也可以不加，不加表示一条条地执行，加表示执行后面的count条指令，然后再停住。

    set step-mode
    set step-mode on
        打开step-mode模式，于是，在进行单步跟踪时，程序不会因为没有debug信息而不停住。这个参数有很利于查看机器码。

    set step-mod off
        关闭step-mode模式。

    finish
        运行程序，直到当前函数完成返回。并打印函数返回时的堆栈地址和返回值及参数值等信息。

    until 或 u
        当你厌倦了在一个循环体内单步跟踪时，这个命令可以运行程序直到退出循环体。

    stepi 或 si
    nexti 或 ni
        单步跟踪一条机器指令！一条程序代码有可能由数条机器指令完成，stepi和nexti可以单步执行机器指令。与之一样有相同功能的命令是 “display/i $pc” ，当运行完这个命令后，单步跟踪会在打出程序代码的同时打出机器指令（也就是汇编代码）

九、信号（Signals）

信号是一种软中断，是一种处理异步事件的方法。一般来说，操作系统都支持许多信号。尤其是UNIX，比较重要应用程序一般都会处理信号。UNIX定义了许多信号，比如SIGINT表示中断字符信号，也就是Ctrl+C的信号，SIGBUS表示硬件故障的信号；SIGCHLD表示子进程状态改变信号； SIGKILL表示终止程序运行的信号，等等。信号量编程是UNIX下非常重要的一种技术。

GDB有能力在你调试程序的时候处理任何一种信号，你可以告诉GDB需要处理哪一种信号。你可以要求GDB收到你所指定的信号时，马上停住正在运行的程序，以供你进行调试。你可以用GDB的handle命令来完成这一功能。

    handle <signal> <keywords...>
        在GDB中定义一个信号处理。信号<signal>可以以SIG开头或不以SIG开头，可以用定义一个要处理信号的范围（如：SIGIO- SIGKILL，表示处理从SIGIO信号到SIGKILL的信号，其中包括SIGIO，SIGIOT，SIGKILL三个信号），也可以使用关键字 all来标明要处理所有的信号。一旦被调试的程序接收到信号，运行程序马上会被GDB停住，以供调试。其<keywords>可以是以下几种关键字的一个或多个。

        nostop
            当被调试的程序收到信号时，GDB不会停住程序的运行，但会打出消息告诉你收到这种信号。
        stop
            当被调试的程序收到信号时，GDB会停住你的程序。
        print
            当被调试的程序收到信号时，GDB会显示出一条信息。
        noprint
            当被调试的程序收到信号时，GDB不会告诉你收到信号的信息。
        pass
        noignore
            当被调试的程序收到信号时，GDB不处理信号。这表示，GDB会把这个信号交给被调试程序会处理。
        nopass
        ignore
            当被调试的程序收到信号时，GDB不会让被调试程序来处理这个信号。

    info signals
    info handle
        查看有哪些信号在被GDB检测中。

十、线程（Thread Stops）

如果你程序是多线程的话，你可以定义你的断点是否在所有的线程上，或是在某个特定的线程。GDB很容易帮你完成这一工作。

    break <linespec> thread <threadno>
    break <linespec> thread <threadno> if ...
        linespec指定了断点设置在的源程序的行号。threadno指定了线程的ID，注意，这个ID是GDB分配的，你可以通过“info threads”命令来查看正在运行程序中的线程信息。如果你不指定thread <threadno>则表示你的断点设在所有线程上面。你还可以为某线程指定断点条件。如：
   
        (gdb) break frik.c:13 thread 28 if bartab > lim

    当你的程序被GDB停住时，所有的运行线程都会被停住。这方便你你查看运行程序的总体情况。而在你恢复程序运行时，所有的线程也会被恢复运行。那怕是主进程在被单步调试时。

查看栈信息
—————

当程序被停住了，你需要做的第一件事就是查看程序是在哪里停住的。当你的程序调用了一个函数，函数的地址，函数参数，函数内的局部变量都会被压入“栈”（Stack）中。你可以用GDB命令来查看当前的栈中的信息。

下面是一些查看函数调用栈信息的GDB命令：

    backtrace
    bt
        打印当前的函数调用栈的所有信息。如：
       
        (gdb) bt
        #0  func (n=250) at tst.c:6
        #1  0x08048524 in main (argc=1, argv=0xbffff674) at tst.c:30
        #2  0x400409ed in __libc_start_main () from /lib/libc.so.6
       
        从上可以看出函数的调用栈信息：__libc_start_main --> main() --> func()
       
   
    backtrace <n>
    bt <n>
        n是一个正整数，表示只打印栈顶上n层的栈信息。

    backtrace <-n>
    bt <-n>
        -n表一个负整数，表示只打印栈底下n层的栈信息。
       
如果你要查看某一层的信息，你需要在切换当前的栈，一般来说，程序停止时，最顶层的栈就是当前栈，如果你要查看栈下面层的详细信息，首先要做的是切换当前栈。

    frame <n>
    f <n>
        n是一个从0开始的整数，是栈中的层编号。比如：frame 0，表示栈顶，frame 1，表示栈的第二层。
   
    up <n>
        表示向栈的上面移动n层，可以不打n，表示向上移动一层。
       
    down <n>
        表示向栈的下面移动n层，可以不打n，表示向下移动一层。
       

    上面的命令，都会打印出移动到的栈层的信息。如果你不想让其打出信息。你可以使用这三个命令：
   
            select-frame <n> 对应于 frame 命令。
            up-silently <n> 对应于 up 命令。
            down-silently <n> 对应于 down 命令。

   
查看当前栈层的信息，你可以用以下GDB命令：

    frame 或 f
        会打印出这些信息：栈的层编号，当前的函数名，函数参数值，函数所在文件及行号，函数执行到的语句。
   
    info frame
    info f
        这个命令会打印出更为详细的当前栈层的信息，只不过，大多数都是运行时的内内地址。比如：函数地址，调用函数的地址，被调用函数的地址，目前的函数是由什么样的程序语言写成的、函数参数地址及值、局部变量的地址等等。如：
            (gdb) info f
            Stack level 0, frame at 0xbffff5d4:
             eip = 0x804845d in func (tst.c:6); saved eip 0x8048524
             called by frame at 0xbffff60c
             source language c.
             Arglist at 0xbffff5d4, args: n=250
             Locals at 0xbffff5d4, Previous frame's sp is 0x0
             Saved registers:
              ebp at 0xbffff5d4, eip at 0xbffff5d8
             
     info args
        打印出当前函数的参数名及其值。
    
     info locals
        打印出当前函数中所有局部变量及其值。
       
     info catch
        打印出当前的函数中的异常处理信息。
       
       
       
       
查看源程序
—————

一、显示源代码

    GDB 可以打印出所调试程序的源代码，当然，在程序编译时一定要加上-g的参数，把源程序信息编译到执行文件中。不然就看不到源程序了。当程序停下来以后， GDB会报告程序停在了那个文件的第几行上。你可以用list命令来打印程序的源代码。还是来看一看查看源代码的GDB命令吧。
   
    list <linenum>
        显示程序第linenum行的周围的源程序。
   
    list <function>
        显示函数名为function的函数的源程序。
       
    list
        显示当前行后面的源程序。
   
    list -
        显示当前行前面的源程序。

一般是打印当前行的上5行和下5行，如果显示函数是是上2行下8行，默认是10行，当然，你也可以定制显示的范围，使用下面命令可以设置一次显示源程序的行数。

    set listsize <count>
        设置一次显示源代码的行数。
       
    show listsize
        查看当前listsize的设置。
       

list命令还有下面的用法：

    list <first>, <last>
        显示从first行到last行之间的源代码。
   
    list , <last>
        显示从当前行到last行之间的源代码。
       
    list +
        往后显示源代码。
       

一般来说在list后面可以跟以下这们的参数：

    <linenum>   行号。
    <+offset>   当前行号的正偏移量。
    <-offset>   当前行号的负偏移量。
    <filename:linenum>  哪个文件的哪一行。
    <function>  函数名。
    <filename:function> 哪个文件中的哪个函数。
    <*address>  程序运行时的语句在内存中的地址。
   

二、搜索源代码

不仅如此，GDB还提供了源代码搜索的命令：

    forward-search <regexp>
    search <regexp>
        向前面搜索。

    reverse-search <regexp>
        全部搜索。
       
其中，<regexp>就是正则表达式，也主一个字符串的匹配模式，关于正则表达式，我就不在这里讲了，还请各位查看相关资料。

三、指定源文件的路径

某些时候，用-g编译过后的执行程序中只是包括了源文件的名字，没有路径名。GDB提供了可以让你指定源文件的路径的命令，以便GDB进行搜索。

    directory <dirname ... >
    dir <dirname ... >
        加一个源文件路径到当前路径的前面。如果你要指定多个路径，UNIX下你可以使用“:”，Windows下你可以使用“;”。
    directory
        清除所有的自定义的源文件搜索路径信息。
   
    show directories
        显示定义了的源文件搜索路径。
       

四、源代码的内存

你可以使用info line命令来查看源代码在内存中的地址。info line后面可以跟“行号”，“函数名”，“文件名:行号”，“文件名:函数名”，这个命令会打印出所指定的源码在运行时的内存地址，如：

        (gdb) info line tst.c:func
        Line 5 of "tst.c" starts at address 0x8048456 <func+6> and ends at 0x804845d <func+13>.

还有一个命令（disassemble）你可以查看源程序的当前执行时的机器码，这个命令会把目前内存中的指令dump出来。如下面的示例表示查看函数func的汇编代码。

        (gdb) disassemble func
        Dump of assembler code for function func:
        0x8048450 <func>:       push   %ebp
        0x8048451 <func+1>:     mov    %esp,%ebp
        0x8048453 <func+3>:     sub    $0x18,%esp
        0x8048456 <func+6>:     movl   $0x0,0xfffffffc(%ebp)
        0x804845d <func+13>:    movl   $0x1,0xfffffff8(%ebp)
        0x8048464 <func+20>:    mov    0xfffffff8(%ebp),%eax
        0x8048467 <func+23>:    cmp    0x8(%ebp),%eax
        0x804846a <func+26>:    jle    0x8048470 <func+32>
        0x804846c <func+28>:    jmp    0x8048480 <func+48>
        0x804846e <func+30>:    mov    %esi,%esi
        0x8048470 <func+32>:    mov    0xfffffff8(%ebp),%eax
        0x8048473 <func+35>:    add    %eax,0xfffffffc(%ebp)
        0x8048476 <func+38>:    incl   0xfffffff8(%ebp)
        0x8048479 <func+41>:    jmp    0x8048464 <func+20>
        0x804847b <func+43>:    nop
        0x804847c <func+44>:    lea    0x0(%esi,1),%esi
        0x8048480 <func+48>:    mov    0xfffffffc(%ebp),%edx
        0x8048483 <func+51>:    mov    %edx,%eax
        0x8048485 <func+53>:    jmp    0x8048487 <func+55>
        0x8048487 <func+55>:    mov    %ebp,%esp
        0x8048489 <func+57>:    pop    %ebp
        0x804848a <func+58>:    ret
        End of assembler dump.

查看运行时数据
———————
   
    在你调试程序时，当程序被停住时，你可以使用print命令（简写命令为p），或是同义命令inspect来查看当前程序的运行数据。print命令的格式是：
   
    print <expr>
    print /<f> <expr>
        <expr>是表达式，是你所调试的程序的语言的表达式（GDB可以调试多种编程语言），<f>是输出的格式，比如，如果要把表达式按16进制的格式输出，那么就是/x。
       
   
一、表达式

    print和许多GDB的命令一样，可以接受一个表达式，GDB会根据当前的程序运行的数据来计算这个表达式，既然是表达式，那么就可以是当前程序运行中的const常量、变量、函数等内容。可惜的是GDB不能使用你在程序中所定义的宏。
   
    表达式的语法应该是当前所调试的语言的语法，由于C/C++是一种大众型的语言，所以，本文中的例子都是关于C/C++的。（而关于用GDB调试其它语言的章节，我将在后面介绍）
   
    在表达式中，有几种GDB所支持的操作符，它们可以用在任何一种语言中。
   
    @
        是一个和数组有关的操作符，在后面会有更详细的说明。
       
    ::
        指定一个在文件或是一个函数中的变量。
       
    {<type>} <addr>
        表示一个指向内存地址<addr>的类型为type的一个对象。
       
       
二、程序变量

    在GDB中，你可以随时查看以下三种变量的值：
        1、全局变量（所有文件可见的）
        2、静态全局变量（当前文件可见的）
        3、局部变量（当前Scope可见的）
       
    如果你的局部变量和全局变量发生冲突（也就是重名），一般情况下是局部变量会隐藏全局变量，也就是说，如果一个全局变量和一个函数中的局部变量同名时，如果当前停止点在函数中，用print显示出的变量的值会是函数中的局部变量的值。如果此时你想查看全局变量的值时，你可以使用“::”操作符：
   
        file::variable
    function::variable
    可以通过这种形式指定你所想查看的变量，是哪个文件中的或是哪个函数中的。例如，查看文件f2.c中的全局变量x的值：
   
    gdb) p 'f2.c'::x
   
    当然，“::”操作符会和C++中的发生冲突，GDB能自动识别“::” 是否C++的操作符，所以你不必担心在调试C++程序时会出现异常。
   
    另外，需要注意的是，如果你的程序编译时开启了优化选项，那么在用GDB调试被优化过的程序时，可能会发生某些变量不能访问，或是取值错误码的情况。这个是很正常的，因为优化程序会删改你的程序，整理你程序的语句顺序，剔除一些无意义的变量等，所以在GDB调试这种程序时，运行时的指令和你所编写指令就有不一样，也就会出现你所想象不到的结果。对付这种情况时，需要在编译程序时关闭编译优化。一般来说，几乎所有的编译器都支持编译优化的开关，例如，GNU 的C/C++编译器GCC，你可以使用“-gstabs”选项来解决这个问题。关于编译器的参数，还请查看编译器的使用说明文档。
   

三、数组

    有时候，你需要查看一段连续的内存空间的值。比如数组的一段，或是动态分配的数据的大小。你可以使用GDB的“@”操作符，“@”的左边是第一个内存的地址的值，“@”的右边则你你想查看内存的长度。例如，你的程序中有这样的语句：
    
        int *array = (int *) malloc (len * sizeof (int));
       
    于是，在GDB调试过程中，你可以以如下命令显示出这个动态数组的取值：

        p *array@len

    @的左边是数组的首地址的值，也就是变量array所指向的内容，右边则是数据的长度，其保存在变量len中，其输出结果，大约是下面这个样子的：
   
        (gdb) p *array@len
        $1 = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40}

    如果是静态数组的话，可以直接用print数组名，就可以显示数组中所有数据的内容了。

   
四、输出格式

    一般来说，GDB会根据变量的类型输出变量的值。但你也可以自定义GDB的输出的格式。例如，你想输出一个整数的十六进制，或是二进制来查看这个整型变量的中的位的情况。要做到这样，你可以使用GDB的数据显示格式：
   
    x  按十六进制格式显示变量。
    d  按十进制格式显示变量。
    u  按十六进制格式显示无符号整型。
    o  按八进制格式显示变量。
    t  按二进制格式显示变量。
    a  按十六进制格式显示变量。
    c  按字符格式显示变量。
    f  按浮点数格式显示变量。

        (gdb) p i
        $21 = 101   
       
        (gdb) p/a i
        $22 = 0x65
       
        (gdb) p/c i
        $23 = 101 'e'
       
        (gdb) p/f i
        $24 = 1.41531145e-43
       
        (gdb) p/x i
        $25 = 0x65
       
        (gdb) p/t i
        $26 = 1100101

五、查看内存

    你可以使用examine命令（简写是x）来查看内存地址中的值。x命令的语法如下所示：
   
    x/<n/f/u> <addr>
   
    n、f、u是可选的参数。
   
    n 是一个正整数，表示显示内存的长度，也就是说从当前地址向后显示几个地址的内容。
    f 表示显示的格式，参见上面。如果地址所指的是字符串，那么格式可以是s，如果地十是指令地址，那么格式可以是i。
    u 表示从当前地址往后请求的字节数，如果不指定的话，GDB默认是4个bytes。u参数可以用下面的字符来代替，b表示单字节，h表示双字节，w表示四字节，g表示八字节。当我们指定了字节长度后，GDB会从指内存定的内存地址开始，读写指定字节，并把其当作一个值取出来。
   
    <addr>表示一个内存地址。

    n/f/u三个参数可以一起使用。例如：
   
    命令：x/3uh 0x54320 表示，从内存地址0x54320读取内容，h表示以双字节为一个单位，3表示三个单位，u表示按十六进制显示。
   
   
六、自动显示

    你可以设置一些自动显示的变量，当程序停住时，或是在你单步跟踪时，这些变量会自动显示。相关的GDB命令是display。
   
    display <expr>
    display/<fmt> <expr>
    display/<fmt> <addr>
   
    expr是一个表达式，fmt表示显示的格式，addr表示内存地址，当你用display设定好了一个或多个表达式后，只要你的程序被停下来，GDB会自动显示你所设置的这些表达式的值。
   
    格式i和s同样被display支持，一个非常有用的命令是：
   
        display/i $pc
   
    $pc是GDB的环境变量，表示着指令的地址，/i则表示输出格式为机器指令码，也就是汇编。于是当程序停下后，就会出现源代码和机器指令码相对应的情形，这是一个很有意思的功能。
   
    下面是一些和display相关的GDB命令：
   
    undisplay <dnums...>
    delete display <dnums...>
    删除自动显示，dnums意为所设置好了的自动显式的编号。如果要同时删除几个，编号可以用空格分隔，如果要删除一个范围内的编号，可以用减号表示（如：2-5）
   
    disable display <dnums...>
    enable display <dnums...>
    disable和enalbe不删除自动显示的设置，而只是让其失效和恢复。
   
    info display
    查看display设置的自动显示的信息。GDB会打出一张表格，向你报告当然调试中设置了多少个自动显示设置，其中包括，设置的编号，表达式，是否enable。

七、设置显示选项

    GDB中关于显示的选项比较多，这里我只例举大多数常用的选项。

    set print address
    set print address on
        打开地址输出，当程序显示函数信息时，GDB会显出函数的参数地址。系统默认为打开的，如：
       
        (gdb) f
        #0  set_quotes (lq=0x34c78 "<<", rq=0x34c88 ">>")
            at input.c:530
        530         if (lquote != def_lquote)

    set print address off
        关闭函数的参数地址显示，如：
       
        (gdb) set print addr off
        (gdb) f
        #0  set_quotes (lq="<<", rq=">>") at input.c:530
        530         if (lquote != def_lquote)

    show print address
        查看当前地址显示选项是否打开。
       
    set print array
    set print array on
        打开数组显示，打开后当数组显示时，每个元素占一行，如果不打开的话，每个元素则以逗号分隔。这个选项默认是关闭的。与之相关的两个命令如下，我就不再多说了。
       
    set print array off
    show print array

    set print elements <number-of-elements>
        这个选项主要是设置数组的，如果你的数组太大了，那么就可以指定一个<number-of-elements>来指定数据显示的最大长度，当到达这个长度时，GDB就不再往下显示了。如果设置为0，则表示不限制。
       
    show print elements
        查看print elements的选项信息。
       
    set print null-stop <on/off>
        如果打开了这个选项，那么当显示字符串时，遇到结束符则停止显示。这个选项默认为off。
       
    set print pretty on
        如果打开printf pretty这个选项，那么当GDB显示结构体时会比较漂亮。如：

            $1 = {
              next = 0x0,
              flags = {
                sweet = 1,
                sour = 1
              },
              meat = 0x54 "Pork"
            }

    set print pretty off
        关闭printf pretty这个选项，GDB显示结构体时会如下显示：
       
            $1 = {next = 0x0, flags = {sweet = 1, sour = 1}, meat = 0x54 "Pork"}
           
    show print pretty
        查看GDB是如何显示结构体的。
       
   
    set print sevenbit-strings <on/off>
        设置字符显示，是否按“\nnn”的格式显示，如果打开，则字符串或字符数据按\nnn显示，如“\065”。
   
    show print sevenbit-strings
        查看字符显示开关是否打开。
       
    set print union <on/off>
        设置显示结构体时，是否显式其内的联合体数据。例如有以下数据结构：
       
        typedef enum {Tree, Bug} Species;
        typedef enum {Big_tree, Acorn, Seedling} Tree_forms;
        typedef enum {Caterpillar, Cocoon, Butterfly}
                      Bug_forms;
       
        struct thing {
          Species it;
          union {
            Tree_forms tree;
            Bug_forms bug;
          } form;
        };
       
        struct thing foo = {Tree, {Acorn}};

        当打开这个开关时，执行 p foo 命令后，会如下显示：
            $1 = {it = Tree, form = {tree = Acorn, bug = Cocoon}}
       
        当关闭这个开关时，执行 p foo 命令后，会如下显示：
            $1 = {it = Tree, form = {...}}

    show print union
        查看联合体数据的显示方式
       
    set print object <on/off>
        在C++中，如果一个对象指针指向其派生类，如果打开这个选项，GDB会自动按照虚方法调用的规则显示输出，如果关闭这个选项的话，GDB就不管虚函数表了。这个选项默认是off。
   
    show print object
        查看对象选项的设置。
       
    set print static-members <on/off>
        这个选项表示，当显示一个C++对象中的内容是，是否显示其中的静态数据成员。默认是on。
   
    show print static-members
        查看静态数据成员选项设置。
       
    set print vtbl <on/off>
        当此选项打开时，GDB将用比较规整的格式来显示虚函数表时。其默认是关闭的。
       
    show print vtbl
        查看虚函数显示格式的选项。
       
       
八、历史记录

    当你用GDB的print查看程序运行时的数据时，你每一个print都会被GDB记录下来。GDB会以$1, $2, $3 .....这样的方式为你每一个print命令编上号。于是，你可以使用这个编号访问以前的表达式，如$1。这个功能所带来的好处是，如果你先前输入了一个比较长的表达式，如果你还想查看这个表达式的值，你可以使用历史记录来访问，省去了重复输入。
   
   
九、GDB环境变量

    你可以在GDB的调试环境中定义自己的变量，用来保存一些调试程序中的运行数据。要定义一个GDB的变量很简单只需。使用GDB的set命令。GDB的环境变量和UNIX一样，也是以$起头。如：
   
    set $foo = *object_ptr
   
    使用环境变量时，GDB会在你第一次使用时创建这个变量，而在以后的使用中，则直接对其賦值。环境变量没有类型，你可以给环境变量定义任一的类型。包括结构体和数组。
   
    show convenience
        该命令查看当前所设置的所有的环境变量。
       
    这是一个比较强大的功能，环境变量和程序变量的交互使用，将使得程序调试更为灵活便捷。例如：
   
        set $i = 0
        print bar[$i++]->contents
   
    于是，当你就不必，print bar[0]->contents, print bar[1]->contents地输入命令了。输入这样的命令后，只用敲回车，重复执行上一条语句，环境变量会自动累加，从而完成逐个输出的功能。
   
   
十、查看寄存器

    要查看寄存器的值，很简单，可以使用如下命令：
   
    info registers
        查看寄存器的情况。（除了浮点寄存器）
   
    info all-registers
        查看所有寄存器的情况。（包括浮点寄存器）
   
    info registers <regname ...>
        查看所指定的寄存器的情况。
       
    寄存器中放置了程序运行时的数据，比如程序当前运行的指令地址（ip），程序的当前堆栈地址（sp）等等。你同样可以使用print命令来访问寄存器的情况，只需要在寄存器名字前加一个$符号就可以了。如：p $eip。

改变程序的执行
———————

    一旦使用GDB挂上被调试程序，当程序运行起来后，你可以根据自己的调试思路来动态地在GDB中更改当前被调试程序的运行线路或是其变量的值，这个强大的功能能够让你更好的调试你的程序，比如，你可以在程序的一次运行中走遍程序的所有分支。
   
   
一、修改变量值

    修改被调试程序运行时的变量值，在GDB中很容易实现，使用GDB的print命令即可完成。如：
   
        (gdb) print x=4
   
    x=4这个表达式是C/C++的语法，意为把变量x的值修改为4，如果你当前调试的语言是Pascal，那么你可以使用Pascal的语法：x:=4。
   
    在某些时候，很有可能你的变量和GDB中的参数冲突，如：
   
        (gdb) whatis width
        type = double
        (gdb) p width
        $4 = 13
        (gdb) set width=47
        Invalid syntax in expression.

    因为，set width是GDB的命令，所以，出现了“Invalid syntax in expression”的设置错误，此时，你可以使用set var命令来告诉GDB，width不是你GDB的参数，而是程序的变量名，如：
   
        (gdb) set var width=47
       
    另外，还可能有些情况，GDB并不报告这种错误，所以保险起见，在你改变程序变量取值时，最好都使用set var格式的GDB命令。
   

二、跳转执行

    一般来说，被调试程序会按照程序代码的运行顺序依次执行。GDB提供了乱序执行的功能，也就是说，GDB可以修改程序的执行顺序，可以让程序执行随意跳跃。这个功能可以由GDB的jump命令来完：
   
    jump <linespec>
    指定下一条语句的运行点。<linespce>可以是文件的行号，可以是file:line格式，可以是+num这种偏移量格式。表式着下一条运行语句从哪里开始。
   
    jump <address>
    这里的<address>是代码行的内存地址。
   
    注意，jump命令不会改变当前的程序栈中的内容，所以，当你从一个函数跳到另一个函数时，当函数运行完返回时进行弹栈操作时必然会发生错误，可能结果还是非常奇怪的，甚至于产生程序Core Dump。所以最好是同一个函数中进行跳转。
   
    熟悉汇编的人都知道，程序运行时，有一个寄存器用于保存当前代码所在的内存地址。所以，jump命令也就是改变了这个寄存器中的值。于是，你可以使用“set $pc”来更改跳转执行的地址。如：
   
    set $pc = 0x485

三、产生信号量

    使用singal命令，可以产生一个信号量给被调试的程序。如：中断信号Ctrl+C。这非常方便于程序的调试，可以在程序运行的任意位置设置断点，并在该断点用GDB产生一个信号量，这种精确地在某处产生信号非常有利程序的调试。
   
    语法是：signal <singal>，UNIX的系统信号量通常从1到15。所以<singal>取值也在这个范围。
   
    single命令和shell的kill命令不同，系统的kill命令发信号给被调试程序时，是由GDB截获的，而single命令所发出一信号则是直接发给被调试程序的。
   

四、强制函数返回

    如果你的调试断点在某个函数中，并还有语句没有执行完。你可以使用return命令强制函数忽略还没有执行的语句并返回。
   
    return
    return <expression>
    使用return命令取消当前函数的执行，并立即返回，如果指定了<expression>，那么该表达式的值会被认作函数的返回值。
   
   
五、强制调用函数

    call <expr>
    表达式中可以一是函数，以此达到强制调用函数的目的。并显示函数的返回值，如果函数返回值是void，那么就不显示。
   
    另一个相似的命令也可以完成这一功能——print，print后面可以跟表达式，所以也可以用他来调用函数，print和call的不同是，如果函数返回void，call则不显示，print则显示函数返回值，并把该值存入历史数据中。

在不同语言中使用GDB
——————————

GDB 支持下列语言：C, C++, Fortran, PASCAL, Java, Chill, assembly, 和 Modula-2。一般说来，GDB会根据你所调试的程序来确定当然的调试语言，比如：发现文件名后缀为“.c”的，GDB会认为是C程序。文件名后缀为 “.C, .cc, .cp, .cpp, .cxx, .c++”的，GDB会认为是C++程序。而后缀是“.f, .F”的，GDB会认为是Fortran程序，还有，后缀为如果是“.s, .S”的会认为是汇编语言。

也就是说，GDB会根据你所调试的程序的语言，来设置自己的语言环境，并让GDB的命令跟着语言环境的改变而改变。比如一些GDB命令需要用到表达式或变量时，这些表达式或变量的语法，完全是根据当前的语言环境而改变的。例如C/C++中对指针的语法是*p，而在Modula-2中则是p^。并且，如果你当前的程序是由几种不同语言一同编译成的，那到在调试过程中，GDB也能根据不同的语言自动地切换语言环境。这种跟着语言环境而改变的功能，真是体贴开发人员的一种设计。

下面是几个相关于GDB语言环境的命令：

    show language
        查看当前的语言环境。如果GDB不能识为你所调试的编程语言，那么，C语言被认为是默认的环境。
       
    info frame
        查看当前函数的程序语言。
       
    info source
        查看当前文件的程序语言。
   
如果GDB没有检测出当前的程序语言，那么你也可以手动设置当前的程序语言。使用set language命令即可做到。

    当set language命令后什么也不跟的话，你可以查看GDB所支持的语言种类：
   
        (gdb) set language
        The currently understood settings are:
       
        local or auto    Automatic setting based on source file
        c                Use the C language
        c++              Use the C++ language
        asm              Use the Asm language
        chill            Use the Chill language
        fortran          Use the Fortran language
        java             Use the Java language
        modula-2         Use the Modula-2 language
        pascal           Use the Pascal language
        scheme           Use the Scheme language
       
    于是你可以在set language后跟上被列出来的程序语言名，来设置当前的语言环境。
   
   

后记
——

    GDB是一个强大的命令行调试工具。大家知道命令行的强大就是在于，其可以形成执行序列，形成脚本。UNIX下的软件全是命令行的，这给程序开发提代供了极大的便利，命令行软件的优势在于，它们可以非常容易的集成在一起，使用几个简单的已有工具的命令，就可以做出一个非常强大的功能。
   
    于是UNIX下的软件比Windows下的软件更能有机地结合，各自发挥各自的长处，组合成更为强劲的功能。而Windows下的图形软件基本上是各自为营，互相不能调用，很不利于各种软件的相互集成。在这里并不是要和Windows做个什么比较，所谓“寸有所长，尺有所短”，图形化工具还是有不如命令行的地方。（看到这句话时，希望各位千万再也不要认为我就是“鄙视图形界面”，和我抬杠了 ）
   
    我是根据版本为5.1.1的GDB所写的这篇文章，所以可能有些功能已被修改，或是又有更为强劲的功能。而且，我写得非常仓促，写得比较简略，并且，其中我已经看到有许多错别字了（我用五笔，所以错字让你看不懂），所以，我在这里对我文中的差错表示万分的歉意。
   
    文中所罗列的GDB的功能时，我只是罗列了一些带用的GDB的命令和使用方法，其实，我这里只讲述的功能大约只占GDB所有功能的60%吧，详细的文档，还是请查看GDB的帮助和使用手册吧，或许，过段时间，如果我有空，我再写一篇GDB的高级使用。
   
    我个人非常喜欢GDB的自动调试的功能，这个功能真的很强大，试想，我在UNIX下写个脚本，让脚本自动编译我的程序，被自动调试，并把结果报告出来，调试成功，自动checkin源码库。一个命令，编译带着调试带着checkin，多爽啊。只是GDB对自动化调试目前支持还不是很成熟，只能实现半自动化，真心期望着GDB的自动化调试功能的成熟。
   
    如果各位对GDB或是别的技术问题有兴趣的话，欢迎和我讨论交流。本人目前主要在UNIX下做产品软件的开发，所以，对UNIX下的软件开发比较熟悉，当然，不单单是技术，对软件工程实施，软件设计，系统分析，项目管理我也略有心得。欢迎大家找我交流，（QQ是：753640，MSN是： haoel@hotmail.com）

#define DEVICE_NAME"s3c2410-adc"
#define ADCRAW_MINOR1
#define ADC_WRITE(ch, prescale)((ch)<<16|(prescale))
#define ADC_WRITE_GETCH(data)(((data)>>16)&0x7)   //得到通道号
#define ADC_WRITE_GETPRE(data)((data)&0xff)      //得到转换的比例因子

static int adcMajor = 0;

typedef struct {
struct semaphore lock;
wait_queue_head_t wait;
int channel;
int prescale;
}ADC_DEV;

static ADC_DEV adcdev;

#define START_ADC_AIN(ch, prescale) \
do{ \
ADCCON = PRESCALE_EN | PRSCVL(prescale) | ADC_INPUT((ch)) ; \
ADCCON |= ADC_START; \
}while(0)

static void adcdone_int_handler(int irq, void *dev_id, struct pt_regs *reg)
{
wake_up(&adcdev.wait);
}

static ssize_t s3c2410_adc_write(struct file *file, const char *buffer, size_t count, loff_t * ppos)
{
int data;

if(count!=sizeof(data)){
printk("the size of  input data must be %d\n", sizeof(data));
return 0;
}
copy_from_user(&data, buffer, count);
adcdev.channel=ADC_WRITE_GETCH(data);
adcdev.prescale=ADC_WRITE_GETPRE(data);
DPRINTK("set adc channel=%d, prescale=0x%x\n", adcdev.channel, adcdev.prescale);
return count;
}

static ssize_t s3c2410_adc_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
{
int ret = 0;
if (down_interruptible(&adcdev.lock))
return -ERESTARTSYS;
START_ADC_AIN(adcdev.channel, adcdev.prescale);
interruptible_sleep_on(&adcdev.wait);
printk("in read channel=%d\n",adcdev.channel);
ret = ADCDAT0;
printk("ADCDAT0=%x\n",ADCDAT0);
while((ADCCON & 0x80)!=1)
udelay(100);
ret &= 0x3ff;
copy_to_user(buffer, (char *)&ret, sizeof(ret));
up(&adcdev.lock);
return sizeof(ret);
}

static int s3c2410_adc_open(struct inode *inode, struct file *filp)
{
init_MUTEX(&adcdev.lock);
init_waitqueue_head(&(adcdev.wait));

adcdev.channel=0;
adcdev.prescale=0xff;

MOD_INC_USE_COUNT;
printk("adc opened!\n");
return 0;
}

static int s3c2410_adc_release(struct inode *inode, struct file *filp)
{
MOD_DEC_USE_COUNT;
printk( "adc closed\n");
return 0;
}

static struct file_operations s3c2410_fops = {
owner:THIS_MODULE,
open:s3c2410_adc_open,
read:s3c2410_adc_read,
write:s3c2410_adc_write,
release:s3c2410_adc_release,
};

#ifdef CONFIG_DEVFS_FS
static devfs_handle_t devfs_adc_dir, devfs_adcraw;
#endif

int __init s3c2410_adc_init(void)
{
int ret;

/* normal ADC */
ADCTSC = 0;
ret = request_irq(IRQ_ADC_DONE, adcdone_int_handler, SA_INTERRUPT, DEVICE_NAME, NULL);
if (ret) {
return ret;
}

ret = register_chrdev(0, DEVICE_NAME, &s3c2410_fops);
if (ret < 0) {
printk(DEVICE_NAME " can't get major number\n");
return ret;
}
adcMajor=ret;

#ifdef CONFIG_DEVFS_FS
devfs_adc_dir = devfs_mk_dir(NULL, "adc", NULL);
devfs_adcraw = devfs_register(devfs_adc_dir, "0raw", DEVFS_FL_DEFAULT,
adcMajor, ADCRAW_MINOR, S_IFCHR | S_IRUSR | S_IWUSR, &s3c2410_fops, NULL);
#endif
printk (DEVICE_NAME"\tinitialized\n");
printk ("initialized\n");

printk("inilized ADCDAT0=%x\n",ADCDAT0);
printk("inilized ADCCON=%x\n",ADCCON);
return 0;
}

module_init(s3c2410_adc_init);

#ifdef MODULE
void __exit s3c2410_adc_exit(void)
{
#ifdef CONFIG_DEVFS_FS
devfs_unregister(devfs_adcraw);
devfs_unregister(devfs_adc_dir);
#endif
unregister_chrdev(adcMajor, DEVICE_NAME);

free_irq(IRQ_ADC_DONE, NULL);
}

module_exit(s3c2410_adc_exit);
MODULE_LICENSE("GPL");
#endif

应用程序：
#include stdio.h>
#include unistd.h>
#include sys/types.h>
#include sys/ipc.h>
#include sys/ioctl.h>
#include fcntl.h>

#define ADC_DEV"/dev/adc/0raw"
#define ADC_WRITE(ch, prescale)((ch)<<16|(prescale))
#define ADC_WRITE_GETCH(data)(((data)>>16)&0x7)   //得到通道号
#define ADC_WRITE_GETPRE(data)((data)&0xff)      //得到转换的比例因子

static int get(int channel)
{
int PRESCALE=0XFF;
int data=ADC_WRITE(channel, PRESCALE);
write(adc_fd, &data, sizeof(data));
read(adc_fd, &data, sizeof(data));
return data;
}

main()
{
int i;
int fd;
float d;
void * retval;
   
if((fd=open(ADC_DEV, O_RDWR))<0)
{
printf("Error opening %s adc device\n", ADC_DEV);
return -1;
}
for(i=0; i<=7; i++)
{
d=((float)get(i)*3.3)/1024.0;
printf("a[%d]=%8.4f\n",i,d);
}
}

源代码包选用目前最新的MPlayer-1.0pre7try2.tar.bz2，这些很容易从网上找到来就不给出联结了。编译工具选择arm-linux-gcc-3.3.2.tar.bz2，这个有70多M，也忘了当初从哪里收集回来的，本人就有这些收破烂的嗜好，没想到这次管用了：）2.95.3的在编译MPlayer-1.0pre7try2这个版本时会有问题，另外网上常见的gcc3.4.1版在编译libavcodec/snow.c文件时会挂掉，不知道是GNU的BUG还是MPlayer的BUG，没时间深究了，那位高人有结论了麻烦通报一下。补丁用不到，可以一帆风顺的完成编译的过程。

一.    安装工具及解压缩源代码

将arm-linux-gcc安装到/usr/local/arm/3.3.2/bin下，确保你现在有root权限哦，假设你的arm-linux-gcc工具包放在~/src目录下，执行以下的操作。当然你也可以将arm-linux-gcc安装到其它地方。

cd /

tar jxvf ~/src/ arm-linux-gcc-3.3.2.tar.bz2

修改$PATH变量包含arm-linux-gcc，我个人习惯修改当前用户home目录下的.bash_profile文件。在.bash_profile文件中增加一行

$PATH=/usr/local/arm/3.3.2/bin: $PATH

也可以不做这一步在以后用的地方用绝对路径。

以上完成了交叉编译工具的安装，接下来该解压MPlayer的源代码了。将MPlayer-1.0pre7try2.tar.bz2拷贝到工作目录(比如~/develop)下。

cp ~/src/MPlayer-1.0pre7try2.tar.bz2 ~/develop

cd ~/develop

tar jxvf MPlayer-1.0pre7try2.tar.bz2

mv MPlayer-1.0pre7try2 MPlayer (这里只是改个名字，原来的实在太长了)

上面应该不会有什么问题的，接下来就要开始编译了，各位看官可要看好了哈，来点掌声鼓励嘛…..哈哈。

二.    开始编译

首先是配置，这里有几个要注意的地方，命令如下：

./configure --host-cc=gcc --cc=arm-linux-gcc --target=arm-armv4l-linux --enable-static --prefix=/tmp/mplayer --disable-win32  --disable-dvdread --enable-fbdev --disable-mencoder --disable-live 2>&1 | tee logfile

--host-cc=gcc是用来编译一些需要在host上执行的中间文件的，如codec-cfg，切记不能少了或搞错了！网上的《mplayer在ARM9(s3c2410)上的移植》(以下简称《移》文)一文介绍说遇到提示codec-cfg不能被执行出错时的解决方法是先将codec-cfg编译成i386平台的在再这里停下来时用i386的codec-cfg替代从而使编译继续。通过实验设置了这个参数就不用那么麻烦了，而且整个过程也显得比较幽雅了。

--cc=arm-linux-gcc这个没什么好介绍的。如果上面没有将arm-linux-gcc的位置加入到$PATH中的话，在这个指定绝对路径好了。

--target=arm-armv4l-linux这个参数要注意的是一个分三部分，第一部分的arm是指arch，这里设定为arm；第二部分的armv4l是指具体的版本，这个要注意了，一定要跟libavcodec目录下的平台目录名一致，否则为这个平台的优化代码没办法编译进去(据我观察是这样的^_@ )；第三部分是系统平台。

--enable-static是设定静态连接，不需要一堆乱七八糟的动态库，尤其对我们这些新手来说省了很多的麻烦。如果设置了这个参数就不用设置—prefix了，另外也不用执行make install。

最后的一个2>&1 | tee logfile意思是将执行的情况在输出到屏幕的同时记录到logfile文件中，在控制台下编译比较有用。

剩余的几个参数没什么好介绍的了，记住--disable-mencoder要加上，mencoder在这里编译会有问题，还没有时间去研究呢。如果不清楚其它的参数的意思自己看configure文件吧，里面都有介绍。

配置完成了就该编译了。执行

make

这里在我的机器上大概花费了2-3分钟的时间。这样在当前目录下就得到可执行的mplayer文件。

三.    试运行

上面我们得到了可以在2410上执行的mplayer了，我是迫不得已的要跑一跑看效果如何。

现介绍一下host的设置。配置host的nfs服务，使host作为一台服务器能够被2410挂上(2410上的内核需要支持nfs哦)。以上的一些步骤很多资料上都有，我就摘录一些了，嘿嘿。

修改/etc/export文件，在其中添加一行: /nfs *(rw,sync,no_root_squash)

关掉防火墙: iptables –F

让nfs服务开机自动执行: setup 后选service

上面的需要重新启动后nfs才能运行起来，如果你现在还不想重起的话，咱们手动让它跑起来: /etc/rc.d/init.d/nfs start

现在可以进行下一步了，将mplayer拷贝到host的nfs根目录里，将要播放的文件也一起拷贝过来

cp mplayer /nfs

cp xxx.avi /nfs

从2410上将主机的/nfs目录挂到开发板上没有使用的一个空目录上来，一般我选/mnt下的目录，如/mnt/nfs

mount –t nfs 192.168.1.222:/nfs /mnt/nfs

现在试试看有没有成功,在终端里输入

cd /mnt/nfs

./mplayer xxx.avi

只见终端稀里哗啦的现实一堆的东西就停下来了。惨了！我是新手啊，让我怎么处理呢。别急慢慢来，先看看提示信息吧。提示信息中大概有这些

can’t open /dev/fb0

vo[null]

can’t open /dev/dsp

ao[null]

先把图像弄出来吧，这样可以证明编译和基本设置都没有问题，声音下一步再处理了。看mplayer手册介绍使用的视频输出是fb.去/dev下面看看发现只有/dev/fb一个而没有/dev/fb0啊。先看看有效的输出设备吧，用mplayer –vo help，挨个挨个试mplayer –vo xx xxx.avi都还是不行。难道是编译过程有问题？解码器什么的各个参数组合都试了一遍，还是一样，LCD没有动静。折腾了几个晚上，我打算放弃了……

一日在网上闲逛，看了一片文章介绍Linux的一些技巧，如cp /dev/fb myimage相当于抓屏。突然我在想那么是不是cp myimage /dev/fb就相当于显示myimage呢？不管它试试再说。果然LCD开始有动作了，虽不是正常的将图片显示出来，但还是可以三个相同的轮廓。此证明LCD的驱动是没有问题的。而mplayer使用的是/dev/fb0我cp的是/dev/fb！而且这个/dev/fb0我好像在什么地方见到过。仔细这么一想，以前内核是有这个/dev/fb0的，现在使用的内核是我自己编译的，而且有/dev/fb这个节点说明framebuff驱动没有问题，那么新旧内核的差别在什么地方？这是我想到好像在编译内核的时候我没有按实际修改mtd的分区参数会不会是这个在作怪呢？

修改drivers\mtd\nand\s3c2410_nand.c文件中的参数为实际对应的参数重新编译内核下载，去/dev目录下一看果然/dev/fb0出现了。….(此处省略xxx字节)追查到/etc/init.d/rcS文件(每个人的配置不一样，请查看你对应的文件)一切真相大白，各位自己去研究这个文件吧。由于文件分区信息不对，内核不能执行/etc/init.d/rcS，导致一些系统初始化动作没有执行。

再试着执行./mplayer xxx.avi还是不对，难道难道…试一试《移》文中的只播放图像不播放声音，./mplayer –nosound xxx.avi哈哈正常了，在320x240的分辨率下相当的流畅，没什么好说的，按《移》文修改声音驱动程序重新编译内核。

到这里本应该结束了，可是…可是…唉，嵌入式就是这样的，成功总是一模一样，错误总是千差万别啊。

• Makefile学习教程: 跟我一起写 Makefile
  • 0 Makefile概述
    • 0.1 关于程序的编译和链接
  • 1 Makefile 介绍
    • 1.1 Makefile的规则
    • 1.2 一个示例
    • 1.3 make是如何工作的
    • 1.4 makefile中使用变量
    • 1.5 让make自动推导
    • 1.6 另类风格的makefile
    • 1.7 清空目标文件的规则
  • 2 Makefile 总述
    • 2.1 Makefile里有什么？
    • 2.2Makefile的文件名
    • 2.3 引用其它的Makefile
    • 2.4 环境变量 MAKEFILES
    • 2.5 make的工作方式
  • 3 Makefile书写规则
    • 3.1 规则举例
    • 3.2 规则的语法
    • 3.3 在规则中使用通配符
    • 3.4 文件搜寻
    • 3.5 伪目标
    • 3.6 多目标
    • 3.7 静态模式
    • 3.8 自动生成依赖性
  • 4 Makefile 书写命令
    • 4.1 显示命令
    • 4.2 命令执行
    • 4.3 命令出错
    • 4.4 嵌套执行make
    • 4.5 定义命令包

0 Makefile概述

因为，makefile关系到了整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。

makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make，Visual C++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。

现在讲述如何写makefile的文章比较少，这是我想写这篇文章的原因。当然，不同产商的make各不相同，也有不同的语法，但其本质都是在“文件依赖性”上做文章，这里，我仅对GNU的make进行讲述，我的环境是RedHat Linux 8.0，make的版本是3.80。必竟，这个make是应用最为广泛的，也是用得最多的。而且其还是最遵循于IEEE 1003.2-1992 标准的（POSIX.2）。

在这篇文档中，将以C/C++的源码作为我们基础，所以必然涉及一些关于C/C++的编译的知识，相关于这方面的内容，还请各位查看相关的编译器的文档。这里所默认的编译器是UNIX下的GCC和CC。

0.1 关于程序的编译和链接

编译时，编译器需要的是语法的正确，函数与变量的声明的正确。对于后者，通常是你需要告诉编译器头文件的所在位置（头文件中应该只是声明，而定义应该放在C/C++文件中），只要所有的语法正确，编译器就可以编译出中间目标文件。一般来说，每个源文件都应该对应于一个中间目标文件（O文件或是OBJ文件）。

链接时，主要是链接函数和全局变量，所以，我们可以使用这些中间目标文件（O文件或是OBJ文件）来链接我们的应用程序。链接器并不管函数所在的源文件，只管函数的中间目标文件（Object File），在大多数时候，由于源文件太多，编译生成的中间目标文件太多，而在链接时需要明显地指出中间目标文件名，这对于编译很不方便，所以，我们要给中间目标文件打个包，在Windows下这种包叫“库文件”（Library File)，也就是 .lib 文件，在UNIX下，是Archive File，也就是 .a 文件。

总结一下，源文件首先会生成中间目标文件，再由中间目标文件生成执行文件。在编译时，编译器只检测程序语法，和函数、变量是否被声明。如果函数未被声明，编译器会给出一个警告，但可以生成Object File。而在链接程序时，链接器会在所有的Object File中找寻函数的实现，如果找不到，那到就会报链接错误码（Linker Error），在VC下，这种错误一般是：Link 2001错误，意思说是说，链接器未能找到函数的实现。你需要指定函数的Object File.

好，言归正传，GNU的make有许多的内容，闲言少叙，还是让我们开始吧。

1 Makefile 介绍

首先，我们用一个示例来说明Makefile的书写规则。以便给大家一个感兴认识。这个示例来源于GNU的make使用手册，在这个示例中，我们的工程有8个C文件，和3个头文件，我们要写一个Makefile来告诉make命令如何编译和链接这几个文件。我们的规则是：

1. 如果这个工程没有编译过，那么我们的所有C文件都要编译并被链接。
2. 如果这个工程的某几个C文件被修改，那么我们只编译被修改的C文件，并链接目标程序。
3. 如果这个工程的头文件被改变了，那么我们需要编译引用了这几个头文件的C文件，并链接目标程序。

只要我们的Makefile写得够好，所有的这一切，我们只用一个make命令就可以完成，make命令会自动智能地根据当前的文件修改的情况来确定哪些文件需要重编译，从而自己编译所需要的文件和链接目标程序。

1.1 Makefile的规则

target ... : prerequisites ...   command   ...   ...

prerequisites就是，要生成那个target所需要的文件或是目标。

command也就是make需要执行的命令。（任意的Shell命令）

这是一个文件的依赖关系，也就是说，target这一个或多个的目标文件依赖于prerequisites中的文件，其生成规则定义在command中。说白一点就是说，prerequisites中如果有一个以上的文件比target文件要新的话，command所定义的命令就会被执行。这就是Makefile的规则。也就是Makefile中最核心的内容。

说到底，Makefile的东西就是这样一点，好像我的这篇文档也该结束了。呵呵。还不尽然，这是Makefile的主线和核心，但要写好一个Makefile还不够，我会以后面一点一点地结合我的工作经验给你慢慢到来。内容还多着呢。：）

1.2 一个示例

    edit : main.o kbd.o command.o display.o            insert.o search.o files.o utils.o            cc -o edit main.o kbd.o command.o display.o                        insert.o search.o files.o utils.o    main.o : main.c defs.h            cc -c main.c    kbd.o : kbd.c defs.h command.h            cc -c kbd.c    command.o : command.c defs.h command.h            cc -c command.c    display.o : display.c defs.h buffer.h            cc -c display.c    insert.o : insert.c defs.h buffer.h            cc -c insert.c    search.o : search.c defs.h buffer.h            cc -c search.c    files.o : files.c defs.h buffer.h command.h            cc -c files.c    utils.o : utils.c defs.h            cc -c utils.c    clean :            rm edit main.o kbd.o command.o display.o                insert.o search.o files.o utils.o

在这个makefile中，目标文件（target）包含：执行文件edit和中间目标文件（*.o），依赖文件（prerequisites）就是冒号后面的那些 .c 文件和 .h文件。每一个 .o 文件都有一组依赖文件，而这些 .o 文件又是执行文件 edit 的依赖文件。依赖关系的实质上就是说明了目标文件是由哪些文件生成的，换言之，目标文件是哪些文件更新的。

在定义好依赖关系后，后续的那一行定义了如何生成目标文件的操作系统命令，一定要以一个Tab键作为开头。记住，make并不管命令是怎么工作的，他只管执行所定义的命令。make会比较targets文件和prerequisites文件的修改日期，如果prerequisites文件的日期要比targets文件的日期要新，或者target不存在的话，那么，make就会执行后续定义的命令。

这里要说明一点的是，clean不是一个文件，它只不过是一个动作名字，有点像C语言中的lable一样，其冒号后什么也没有，那么，make就不会自动去找文件的依赖性，也就不会自动执行其后所定义的命令。要执行其后的命令，就要在make命令后明显得指出这个lable的名字。这样的方法非常有用，我们可以在一个makefile中定义不用的编译或是和编译无关的命令，比如程序的打包，程序的备份，等等。

1.3 make是如何工作的

1. make会在当前目录下找名字叫“Makefile”或“makefile”的文件。
2. 如果找到，它会找文件中的第一个目标文件（target），在上面的例子中，他会找到“edit”这个文件，并把这个文件作为最终的目标文件。
3. 如果edit文件不存在，或是edit所依赖的后面的 .o 文件的文件修改时间要比edit这个文件新，那么，他就会执行后面所定义的命令来生成edit这个文件。
4. 如果edit所依赖的.o文件也存在，那么make会在当前文件中找目标为.o文件的依赖性，如果找到则再根据那一个规则生成.o文件。（这有点像一个堆栈的过程）
5. 当然，你的C文件和H文件是存在的啦，于是make会生成 .o 文件，然后再用 .o 文件生命make的终极任务，也就是执行文件edit了。

这就是整个make的依赖性，make会一层又一层地去找文件的依赖关系，直到最终编译出第一个目标文件。在找寻的过程中，如果出现错误，比如最后被依赖的文件找不到，那么make就会直接退出，并报错，而对于所定义的命令的错误，或是编译不成功，make根本不理。make只管文件的依赖性，即，如果在我找了依赖关系之后，冒号后面的文件还是不在，那么对不起，我就不工作啦。

通过上述分析，我们知道，像clean这种，没有被第一个目标文件直接或间接关联，那么它后面所定义的命令将不会被自动执行，不过，我们可以显示要make执行。即命令——“make clean”，以此来清除所有的目标文件，以便重编译。

于是在我们编程中，如果这个工程已被编译过了，当我们修改了其中一个源文件，比如file.c，那么根据我们的依赖性，我们的目标file.o会被重编译（也就是在这个依性关系后面所定义的命令），于是file.o的文件也是最新的啦，于是file.o的文件修改时间要比edit要新，所以edit也会被重新链接了（详见edit目标文件后定义的命令）。

而如果我们改变了“command.h”，那么，kdb.o、command.o和files.o都会被重编译，并且，edit会被重链接。

1.4 makefile中使用变量

      edit : main.o kbd.o command.o display.o                   insert.o search.o files.o utils.o            cc -o edit main.o kbd.o command.o display.o                        insert.o search.o files.o utils.o

比如，我们声明一个变量，叫objects, OBJECTS, objs, OBJS, obj, 或是 OBJ，反正不管什么啦，只要能够表示obj文件就行了。我们在makefile一开始就这样定义：

     objects = main.o kbd.o command.o display.o               insert.o search.o files.o utils.o

    objects = main.o kbd.o command.o display.o               insert.o search.o files.o utils.o    edit : $(objects)            cc -o edit $(objects)    main.o : main.c defs.h            cc -c main.c    kbd.o : kbd.c defs.h command.h            cc -c kbd.c    command.o : command.c defs.h command.h            cc -c command.c    display.o : display.c defs.h buffer.h            cc -c display.c    insert.o : insert.c defs.h buffer.h            cc -c insert.c    search.o : search.c defs.h buffer.h            cc -c search.c    files.o : files.c defs.h buffer.h command.h            cc -c files.c    utils.o : utils.c defs.h            cc -c utils.c    clean :            rm edit $(objects)

于是如果有新的 .o 文件加入，我们只需简单地修改一下 objects 变量就可以了。

关于变量更多的话题，我会在后续给你一一道来。

1.5 让make自动推导

只要make看到一个[.o]文件，它就会自动的把[.c]文件加在依赖关系中，如果make找到一个whatever.o，那么whatever.c，就会是whatever.o的依赖文件。并且 cc -c whatever.c 也会被推导出来，于是，我们的makefile再也不用写得这么复杂。我们的是新的makefile又出炉了。

    objects = main.o kbd.o command.o display.o               insert.o search.o files.o utils.o    edit : $(objects)            cc -o edit $(objects)    main.o : defs.h    kbd.o : defs.h command.h    command.o : defs.h command.h    display.o : defs.h buffer.h    insert.o : defs.h buffer.h    search.o : defs.h buffer.h    files.o : defs.h buffer.h command.h    utils.o : defs.h    .PHONY : clean    clean :            rm edit $(objects)

关于更为详细的“隐晦规则”和“伪目标文件”，我会在后续给你一一道来。

1.6 另类风格的makefile

    objects = main.o kbd.o command.o display.o               insert.o search.o files.o utils.o    edit : $(objects)            cc -o edit $(objects)    $(objects) : defs.h    kbd.o command.o files.o : command.h    display.o insert.o search.o files.o : buffer.h    .PHONY : clean    clean :            rm edit $(objects)

1.7 清空目标文件的规则

        clean:            rm edit $(objects)

        .PHONY : clean        clean :                -rm edit $(objects)

上面就是一个makefile的概貌，也是makefile的基础，下面还有很多makefile的相关细节，准备好了吗？准备好了就来。

2 Makefile 总述

2.1 Makefile里有什么？

1. 显式规则。显式规则说明了，如何生成一个或多的的目标文件。这是由Makefile的书写者明显指出，要生成的文件，文件的依赖文件，生成的命令。
2. 隐晦规则。由于我们的make有自动推导的功能，所以隐晦的规则可以让我们比较粗糙地简略地书写Makefile，这是由make所支持的。
3. 变量的定义。在Makefile中我们要定义一系列的变量，变量一般都是字符串，这个有点你C语言中的宏，当Makefile被执行时，其中的变量都会被扩展到相应的引用位置上。
4. 文件指示。其包括了三个部分，一个是在一个Makefile中引用另一个Makefile，就像C语言中的include一样；另一个是指根据某些情况指定Makefile中的有效部分，就像C语言中的预编译#if一样；还有就是定义一个多行的命令。有关这一部分的内容，我会在后续的部分中讲述。
5. 注释。Makefile中只有行注释，和UNIX的Shell脚本一样，其注释是用“#”字符，这个就像C/C++中的“//”一样。如果你要在你的Makefile中使用“#”字符，可以用反斜框进行转义，如：“\#”。

最后，还值得一提的是，在Makefile中的命令，必须要以[Tab]键开始。

2.2Makefile的文件名

当然，你可以使用别的文件名来书写Makefile，比如：“Make.Linux”，“Make.Solaris”，“Make.AIX”等，如果要指定特定的Makefile，你可以使用make的“-f”和“--file”参数，如：make -f Make.Linux或make --file Make.AIX。

2.3 引用其它的Makefile

include <filename>

在include前面可以有一些空字符，但是绝不能是[Tab]键开始。include和可以用一个或多个空格隔开。举个例子，你有这样几个Makefile：a.mk、b.mk、c.mk，还有一个文件叫foo.make，以及一个变量$(bar)，其包含了e.mk和f.mk，那么，下面的语句：

    include foo.make *.mk $(bar)

    include foo.make a.mk b.mk c.mk e.mk f.mk

1. 如果make执行时，有“-I”或“--include-dir”参数，那么make就会在这个参数所指定的目录下去寻找。
2. 如果目录 /include（一般是：/usr/local/bin或/usr/include）存在的话，make也会去找。

如果有文件没有找到的话，make会生成一条警告信息，但不会马上出现致命错误。它会继续载入其它的文件，一旦完成makefile的读取，make会再重试这些没有找到，或是不能读取的文件，如果还是不行，make才会出现一条致命信息。如果你想让make不理那些无法读取的文件，而继续执行，你可以在include前加一个减号“-”。如：

-include <filename>

2.4 环境变量 MAKEFILES

但是在这里我还是建议不要使用这个环境变量，因为只要这个变量一被定义，那么当你使用make时，所有的Makefile都会受到它的影响，这绝不是你想看到的。在这里提这个事，只是为了告诉大家，也许有时候你的Makefile出现了怪事，那么你可以看看当前环境中有没有定义这个变量。

2.5 make的工作方式

1. 读入所有的Makefile。
2. 读入被include的其它Makefile。
3. 初始化文件中的变量。
4. 推导隐晦规则，并分析所有规则。
5. 为所有的目标文件创建依赖关系链。
6. 根据依赖关系，决定哪些目标要重新生成。
7. 执行生成命令。

1-5步为第一个阶段，6-7为第二个阶段。第一个阶段中，如果定义的变量被使用了，那么，make会把其展开在使用的位置。但make并不会完全马上展开，make使用的是拖延战术，如果变量出现在依赖关系的规则中，那么仅当这条依赖被决定要使用了，变量才会在其内部展开。

当然，这个工作方式你不一定要清楚，但是知道这个方式你也会对make更为熟悉。有了这个基础，后续部分也就容易看懂了。

3 Makefile书写规则

在Makefile中，规则的顺序是很重要的，因为，Makefile中只应该有一个最终目标，其它的目标都是被这个目标所连带出来的，所以一定要让make知道你的最终目标是什么。一般来说，定义在Makefile中的目标可能会有很多，但是第一条规则中的目标将被确立为最终的目标。如果第一条规则中的目标有很多个，那么，第一个目标会成为最终的目标。make所完成的也就是这个目标。

好了，还是让我们来看一看如何书写规则。

3.1 规则举例

 foo.o : foo.c defs.h       # foo模块            cc -c -g foo.c

1. 文件的依赖关系，foo.o依赖于foo.c和defs.h的文件，如果foo.c和defs.h的文件日期要比foo.o文件日期要新，或是foo.o不存在，那么依赖关系发生。
2. 如果生成（或更新）foo.o文件。也就是那个cc命令，其说明了，如何生成foo.o这个文件。（当然foo.c文件include了defs.h文件）

3.2 规则的语法

      targets : prerequisites        command        ...

      targets : prerequisites ; command            command            ...

command是命令行，如果其不与“target:prerequisites”在一行，那么，必须以[Tab键]开头，如果和prerequisites在一行，那么可以用分号做为分隔。（见上）

prerequisites也就是目标所依赖的文件（或依赖目标）。如果其中的某个文件要比目标文件要新，那么，目标就被认为是“过时的”，被认为是需要重生成的。这个在前面已经讲过了。

如果命令太长，你可以使用反斜框（‘\’）作为换行符。make对一行上有多少个字符没有限制。规则告诉make两件事，文件的依赖关系和如何成成目标文件。

一般来说，make会以UNIX的标准Shell，也就是/bin/sh来执行命令。

3.3 在规则中使用通配符

如果我们想定义一系列比较类似的文件，我们很自然地就想起使用通配符。make支持三各通配符：“*”，“?”和“[...]”。这是和Unix的B-Shell是相同的。

波浪号（“~”）字符在文件名中也有比较特殊的用途。如果是“~/test”，这就表示当前用户的$HOME目录下的test目录。而“~hchen/test”则表示用户hchen的宿主目录下的test目录。（这些都是Unix下的小知识了，make也支持）而在Windows或是MS-DOS下，用户没有宿主目录，那么波浪号所指的目录则根据环境变量“HOME”而定。

通配符代替了你一系列的文件，如“*.c”表示所以后缀为c的文件。一个需要我们注意的是，如果我们的文件名中有通配符，如：“*”，那么可以用转义字符“\”，如“\*”来表示真实的“*”字符，而不是任意长度的字符串。

好吧，还是先来看几个例子吧：

    clean:         rm -f *.o

    print: *.c         lpr -p $?         touch print

    objects = *.o

    objects := $(wildcard *.o)

3.4 文件搜寻

在一些大的工程中，有大量的源文件，我们通常的做法是把这许多的源文件分类，并存放在不同的目录中。所以，当make需要去找寻文件的依赖关系时，你可以在文件前加上路径，但最好的方法是把一个路径告诉make，让make在自动去找。

Makefile文件中的特殊变量“VPATH”就是完成这个功能的，如果没有指明这个变量，make只会在当前的目录中去找寻依赖文件和目标文件。如果定义了这个变量，那么，make就会在当当前目录找不到的情况下，到所指定的目录中去找寻文件了。

    VPATH = src:../headers

另一个设置文件搜索路径的方法是使用make的“vpath”关键字（注意，它是全小写的），这不是变量，这是一个make的关键字，这和上面提到的那个VPATH变量很类似，但是它更为灵活。它可以指定不同的文件在不同的搜索目录中。这是一个很灵活的功能。它的使用方法有三种：

1. vpath < pattern> < directories>
   为符合模式< pattern>的文件指定搜索目录< directories>。
2. vpath < pattern>
   清除符合模式< pattern>的文件的搜索目录。
3. vpath
   清除所有已被设置好了的文件搜索目录。

vapth使用方法中的< pattern>需要包含“%”字符。“%”的意思是匹配零或若干字符，例如，“%.h”表示所有以“.h”结尾的文件。< pattern>指定了要搜索的文件集，而< directories>则指定了 的文件集的搜索的目录。例如：

    vpath %.h ../headers

我们可以连续地使用vpath语句，以指定不同搜索策略。如果连续的vpath语句中出现了相同的< pattern>，或是被重复了的< pattern>，那么，make会按照vpath语句的先后顺序来执行搜索。如：

    vpath %.c foo    vpath %   blish    vpath %.c bar

    vpath %.c foo:bar    vpath %   blish

3.5 伪目标

最早先的一个例子中，我们提到过一个“clean”的目标，这是一个“伪目标”，

    clean:            rm *.o temp

因为，我们并不生成“clean”这个文件。“伪目标”并不是一个文件，只是一个标签，由于“伪目标”不是文件，所以make无法生成它的依赖关系和决定它是否要执行。我们只有通过显示地指明这个“目标”才能让其生效。当然，“伪目标”的取名不能和文件名重名，不然其就失去了“伪目标”的意义了。

当然，为了避免和文件重名的这种情况，我们可以使用一个特殊的标记“.PHONY”来显示地指明一个目标是“伪目标”，向make说明，不管是否有这个文件，这个目标就是“伪目标”。

    .PHONY : clean

     .PHONY: clean    clean:            rm *.o temp

    all : prog1 prog2 prog3    .PHONY : all    prog1 : prog1.o utils.o            cc -o prog1 prog1.o utils.o    prog2 : prog2.o            cc -o prog2 prog2.o    prog3 : prog3.o sort.o utils.o            cc -o prog3 prog3.o sort.o utils.o

随便提一句，从上面的例子我们可以看出，目标也可以成为依赖。所以，伪目标同样也可成为依赖。看下面的例子：

    .PHONY: cleanall cleanobj cleandiff    cleanall : cleanobj cleandiff            rm program    cleanobj :            rm *.o    cleandiff :            rm *.diff

3.6 多目标

Makefile的规则中的目标可以不止一个，其支持多目标，有可能我们的多个目标同时依赖于一个文件，并且其生成的命令大体类似。于是我们就能把其合并起来。当然，多个目标的生成规则的执行命令是同一个，这可能会可我们带来麻烦，不过好在我们的可以使用一个自动化变量“$@”（关于自动化变量，将在后面讲述），这个变量表示着目前规则中所有的目标的集合，这样说可能很抽象，还是看一个例子吧。

    bigoutput littleoutput : text.g            generate text.g -$(subst output,,$@) > $@
    上述规则等价于：
    bigoutput : text.g    generate text.g -big > bigoutput    littleoutput : text.g    generate text.g -little > littleoutput    

3.7 静态模式

静态模式可以更加容易地定义多目标的规则，可以让我们的规则变得更加的有弹性和灵活。我们还是先来看一下语法：

<targets ...>: <target-pattern>: <prereq-patterns ...>　　　<commands>...

targets定义了一系列的目标文件，可以有通配符。是目标的一个集合。

target-parrtern是指明了targets的模式，也就是的目标集模式。

prereq-parrterns是目标的依赖模式，它对target-parrtern形成的模式再进行一次依赖目标的定义。

这样描述这三个东西，可能还是没有说清楚，还是举个例子来说明一下吧。如果我们的定义成“%.o”，意思是我们的集合中都是以“.o”结尾的，而如果我们的 定义成“%.c”，意思是对所形成的目标集进行二次定义，其计算方法是，取模式中的“%”（也就是去掉了[.o]这个结尾），并为其加上[.c]这个结尾，形成的新集合。

所以，我们的“目标模式”或是“依赖模式”中都应该有“%”这个字符，如果你的文件名中有“%”那么你可以使用反斜杠“\”进行转义，来标明真实的“%”字符。

看一个例子：

    objects = foo.o bar.o    all: $(objects)    $(objects): %.o: %.c            $(CC) -c $(CFLAGS) ___FCKpd___34lt; -o $@

    foo.o : foo.c            $(CC) -c $(CFLAGS) foo.c -o foo.o    bar.o : bar.c            $(CC) -c $(CFLAGS) bar.c -o bar.o

    files = foo.elc bar.o lose.o    $(filter %.o,$(files)): %.o: %.c            $(CC) -c $(CFLAGS) ___FCKpd___36lt; -o $@    $(filter %.elc,$(files)): %.elc: %.el            emacs -f batch-byte-compile ___FCKpd___36lt;

$(filter %.o,$(files))表示调用Makefile的filter函数，过滤“$filter”集，只要其中模式为“%.o”的内容。其的它内容，我就不用多说了吧。这个例字展示了Makefile中更大的弹性。

3.8 自动生成依赖性

在Makefile中，我们的依赖关系可能会需要包含一系列的头文件，比如，如果我们的main.c中有一句“#include "defs.h"”，那么我们的依赖关系应该是：

    main.o : main.c defs.h

    cc -M main.c

    main.o : main.c defs.h

gcc -M main.c的输出是：

    main.o: main.c defs.h /usr/include/stdio.h /usr/include/features.h          /usr/include/sys/cdefs.h /usr/include/gnu/stubs.h          /usr/lib/gcc-lib/i486-suse-linux/2.95.3/include/stddef.h          /usr/include/bits/types.h /usr/include/bits/pthreadtypes.h          /usr/include/bits/sched.h /usr/include/libio.h          /usr/include/_G_config.h /usr/include/wchar.h          /usr/include/bits/wchar.h /usr/include/gconv.h          /usr/lib/gcc-lib/i486-suse-linux/2.95.3/include/stdarg.h          /usr/include/bits/stdio_lim.h

    main.o: main.c defs.h

于是，我们可以写出[.c]文件和[.d]文件的依赖关系，并让make自动更新或自成[.d]文件，并把其包含在我们的主Makefile中，这样，我们就可以自动化地生成每个文件的依赖关系了。

这里，我们给出了一个模式规则来产生[.d]文件：

    %.d: %.c            @set -e; rm -f $@;              $(CC) -M $(CPPFLAGS) ___FCKpd___42lt; > $@.$$;              sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$ > $@;              rm -f $@.$$

这个规则的意思是，所有的[.d]文件依赖于[.c]文件，“rm -f $@”的意思是删除所有的目标，也就是[.d]文件，第二行的意思是，为每个依赖文件“$<”，也就是[.c]文件生成依赖文件，“$@”表示模式“%.d”文件，如果有一个C文件是name.c，那么“%”就是“name”，“$$$$”意为一个随机编号，第二行生成的文件有可能是“name.d.12345”，第三行使用sed命令做了一个替换，关于sed命令的用法请参看相关的使用文档。第四行就是删除临时文件。

总而言之，这个模式要做的事就是在编译器生成的依赖关系中加入[.d]文件的依赖，即把依赖关系：

    main.o : main.c defs.h

    main.o main.d : main.c defs.h

    sources = foo.c bar.c    include $(sources:.c=.d)

4 Makefile 书写命令

每条规则中的命令和操作系统Shell的命令行是一致的。make会一按顺序一条一条的执行命令，每条命令的开头必须以[Tab]键开头，除非，命令是紧跟在依赖规则后面的分号后的。在命令行之间中的空格或是空行会被忽略，但是如果该空格或空行是以Tab键开头的，那么make会认为其是一个空命令。

我们在UNIX下可能会使用不同的Shell，但是make的命令默认是被“/bin/sh”——UNIX的标准Shell解释执行的。除非你特别指定一个其它的Shell。Makefile中，“#”是注释符，很像C/C++中的“//”，其后的本行字符都被注释。

4.1 显示命令

通常，make会把其要执行的命令行在命令执行前输出到屏幕上。当我们用“@”字符在命令行前，那么，这个命令将不被make显示出来，最具代表性的例子是，我们用这个功能来像屏幕显示一些信息。如：

    @echo 正在编译XXX模块......

    echo 正在编译XXX模块......    正在编译XXX模块......

而make参数“-s”或“--slient”则是全面禁止命令的显示。

4.2 命令执行

当依赖目标新于目标时，也就是当规则的目标需要被更新时，make会一条一条的执行其后的命令。需要注意的是，如果你要让上一条命令的结果应用在下一条命令时，你应该使用分号分隔这两条命令。比如你的第一条命令是cd命令，你希望第二条命令得在cd之后的基础上运行，那么你就不能把这两条命令写在两行上，而应该把这两条命令写在一行上，用分号分隔。如：

    示例一：        exec:                cd /home/hchen                pwd    示例二：        exec:                cd /home/hchen; pwd

当我们执行“make exec”时，第一个例子中的cd没有作用，pwd会打印出当前的Makefile目录，而第二个例子中，cd就起作用了，pwd会打印出“/home/hchen”。

make一般是使用环境变量SHELL中所定义的系统Shell来执行命令，默认情况下使用UNIX的标准Shell——/bin/sh来执行命令。但在MS-DOS下有点特殊，因为MS-DOS下没有SHELL环境变量，当然你也可以指定。如果你指定了UNIX风格的目录形式，首先，make会在SHELL所指定的路径中找寻命令解释器，如果找不到，其会在当前盘符中的当前目录中寻找，如果再找不到，其会在PATH环境变量中所定义的所有路径中寻找。MS-DOS中，如果你定义的命令解释器没有找到，其会给你的命令解释器加上诸如“.exe”、“.com”、“.bat”、“.sh”等后缀。

4.3 命令出错

每当命令运行完后，make会检测每个命令的返回码，如果命令返回成功，那么make会执行下一条命令，当规则中所有的命令成功返回后，这个规则就算是成功完成了。如果一个规则中的某个命令出错了（命令退出码非零），那么make就会终止执行当前规则，这将有可能终止所有规则的执行。

有些时候，命令的出错并不表示就是错误的。例如mkdir命令，我们一定需要建立一个目录，如果目录不存在，那么mkdir就成功执行，万事大吉，如果目录存在，那么就出错了。我们之所以使用mkdir的意思就是一定要有这样的一个目录，于是我们就不希望mkdir出错而终止规则的运行。

为了做到这一点，忽略命令的出错，我们可以在Makefile的命令行前加一个减号“-”（在Tab键之后），标记为不管命令出不出错都认为是成功的。如：

   clean:            -rm -f *.o

还有一个要提一下的make的参数的是“-k”或是“--keep-going”，这个参数的意思是，如果某规则中的命令出错了，那么就终目该规则的执行，但继续执行其它规则。

4.4 嵌套执行make

在一些大的工程中，我们会把我们不同模块或是不同功能的源文件放在不同的目录中，我们可以在每个目录中都书写一个该目录的Makefile，这有利于让我们的Makefile变得更加地简洁，而不至于把所有的东西全部写在一个Makefile中，这样会很难维护我们的Makefile，这个技术对于我们模块编译和分段编译有着非常大的好处。

例如，我们有一个子目录叫subdir，这个目录下有个Makefile文件，来指明了这个目录下文件的编译规则。那么我们总控的Makefile可以这样书写：

    subsystem:            cd subdir && $(MAKE)其等价于：    subsystem:            $(MAKE) -C subdir
定义$(MAKE)宏变量的意思是，也许我们的make需要一些参数，所以定义成一个变量比较利于维护。这两个例子的意思都是先进入“subdir”目录，然后执行make命令。我们把这个Makefile叫做“总控Makefile”，总控Makefile的变量可以传递到下级的Makefile中（如果你显示的声明），但是不会覆盖下层的Makefile中所定义的变量，除非指定了“-e”参数。如果你要传递变量到下级Makefile中，那么你可以使用这样的声明：
export <variable ...>

unexport <variable ...>

        示例一：        export variable = value        其等价于：        variable = value        export variable        其等价于：        export variable := value        其等价于：        variable := value        export variable    示例二：        export variable += value        其等价于：        variable += value        export variable

需要注意的是，有两个变量，一个是SHELL，一个是MAKEFLAGS，这两个变量不管你是否export，其总是要传递到下层Makefile中，特别是MAKEFILES变量，其中包含了make的参数信息，如果我们执行“总控Makefile”时有make参数或是在上层Makefile中定义了这个变量，那么MAKEFILES变量将会是这些参数，并会传递到下层Makefile中，这是一个系统级的环境变量。

但是make命令中的有几个参数并不往下传递，它们是“-C”,“-f”,“-h”“-o”和“-W”（有关Makefile参数的细节将在后面说明），如果你不想往下层传递参数，那么，你可以这样来：

        subsystem:            cd subdir && $(MAKE) MAKEFLAGS=

还有一个在“嵌套执行”中比较有用的参数，“-w”或是“--print-directory”会在make的过程中输出一些信息，让你看到目前的工作目录。比如，如果我们的下级make目录是“/home/hchen/gnu/make”，如果我们使用“make -w”来执行，那么当进入该目录时，我们会看到：

        make: Entering directory `/home/hchen/gnu/make'.

        make: Leaving directory `/home/hchen/gnu/make'

4.5 定义命令包

如果Makefile中出现一些相同命令序列，那么我们可以为这些相同的命令序列定义一个变量。定义这种命令序列的语法以“define”开始，以“endef”结束，如：

    define run-yacc    yacc $(firstword $^)    mv y.tab.c $@    endef

    foo.c : foo.y            $(run-yacc)

作者 Ray

RTEMS版权所有，转载请注明：来源 http://www.rtems.net，作者 ray@rtems.net

        笔者受公司委托对 2.6 的内核作了一个性能评估，评测的对象包括进程切换性能，线程切换性能，网络性能，内存读取速度，文件系统性能几个方面。结果表明，在工作站的模式下 2.6 的内核大多数指标比不上 2.4 内核的性能。在服务器模式下， 2.6 内核才开始有优势。同时，本文使用 FreeBSD 作为参照比较对象。

Linux2.6 内核的新特性

网上不少文章介绍了2.6内核的新特性，这里我就照搬过来。

内存管理

1 ．抢占式内存

2.6 版本以前的 Linux 内核是不允许对一个被系统调用并处于运行状态的进程进行调度的。这意味着一旦系统调用中有某个任务正在执行，那么该任务会控制处理器直到系统调用结束，而 不管其使用处理器时间的长短。（2.4是分时的，为什么网上的系统说“直到系统调用结束” ？？）

2.6 版内核中内存是可抢占的。一些人认为可抢占式内存使 Linux 2.6 内核在一些时效性较强的事件中比 2.4 版内核具有更好的响应能力。为实现抢占式内存， Linux 2.6 内核中的代码被设置了抢占点，这意味着调度程序会中止正在运行的进程，而来执行优先级更高的进程。在系统调用过程中， Linux 2.6 内核会定时地检查抢占点，以避免不合理的延迟发生。而在检查过程中，调度进程很可能就会中止当前进程来让另一个进程运行。

实际上，测试表明抢占内核使工作站环境下的应用程序速度变慢。

2 ．引入内存池机制

2.6 版内核的开发过程引入了内存池以满足不间断地进行内存分配。其思想是预先分配一个内存池，并保留到真正需要的时候。 哈哈，其结果是系统一启动，大量的内存就没有了。

3 ．改善虚拟内存

2.6 版内核改善了虚拟内存在一定程度负载下的性能。 通过反向地址映射减少了系统的开销。

Linux 内核工作于虚拟内存模式时，每一个虚拟页对应一个相应系统内存的物理页。虚拟页和物理页之间的地址转换由硬件页表来完成。但是这种“虚拟到物理”的页映射 不总是一一对应的，多个虚拟页有可能指向同一个物理页。这种情况下，内核想要释放特定的物理页就必须遍历所有的进程页表记录来查找指向这个物理页的引用， 只有在引用数达到 0 时才能释放该物理页。负载较高时，这会让虚拟内存变得非常慢。

反向地址映射补丁通过在结构页引入一个叫做 pte_chain 的数据结构来解决这一问题。

不过，这种方法存在一个指针开销问题。系统中的每一个结构页都必须有一个额外的、用于 pte_chain 的结构。一个 256MB 内存的系统有 64K 个物理页，这就需要有 64KB* （ sizeof （ struct pte_chain ））的内存被分配用于 pte_chain 的结构。

使用了这项技术， r-map 的性能，尤其是高负载的高端系统，相对于 2.4 版内核的虚拟内存系统还是有了显著地提高。

4 ．共享内存的改进

Linux 2.6 内核为多程序提供了一种不同的途径，即 NUMA （ Non Uniform Memory Access ）。这种方法中，内存和处理器是相互连接的，但对于每一个处理器，某些内存是“关闭”的，而某些内存则“更远”。这意味着当内存竞争出现时，“更近”的处 理器对就近的内存有更高的使用权。 2.6 版内核提供了一套功能来定义内存和处理器之间的拓扑关系。调度程序可以利用这些信息来为任务分配本地内存。这样将减少内存竞争造成的瓶颈，提高吞吐量。

驱动程序

1 ．中断例程的改进

在 2.6 版内核中，驱动程序如果要从一个设备上发出中断需要返回 IRQ_HANDLED ，否则返回 IRQ_NONE 。这样可以帮助内核的 IRQ 层清楚地识别出哪个驱动程序正在处理哪个特定的中断。 如果一个中断请求不断到来，而且没有注册那个设备的处理程序，内核就会忽略来自该设备的中断。

2 ．驱动程序移植

相对于 2.4 版内核来说， 2.6 版内核改进了内核编译系统，从而获得更快的编译速度。 2.6 版内核的编译系统加入了改进的图形化工具 make xconfig （需要 Qt 库）和 make gconfig

内核模块加载器也在 2.6 版内核中被完全实现，使得模块编译机制相对于 2.4 版内核有了很大的不同。原来 2.4 版内核中的模块工具不能用来加载或卸载 2.6 版内核的模块，需要一组新的模块工具来完成模块的加载和卸载。这个新的模块加载工具会尽量减少在一个设备仍被使用的情况下，相应的模块却被卸载的冲突发 生，而是在确认这些模块已经没有任何设备在使用后再卸载掉。产生这种冲突的原因之一是，模块使用计数是由模块代码自己来控制的。在 2.6 版内核中，模块不再需要对引用计数进行加减，这些工作将在模块代码外部进行。

进程管理

1 ．新调度器算法

2.6 版本的 Linux 内核使用了新的调度器算法，称为 O （ 1 ）算法，它在高负载的情况下执行得非常出色，并在有多个处理器时能够很好地扩展。

2.4 版本的调度器中，时间片重算算法要求在所有的进程都用尽它们的时间片后，新时间片才会被重新计算。在一个多处理器系统中，当进程用完它们的时间片后不得不 等待重算，以得到新的时间片，从而导致大部分处理器处于空闲状态，影响 SMP 的效率。此外，当空闲处理器开始执行那些时间片尚未用尽的、处于等待状态的进程时，会导致进程开始在处理器之间“跳跃”。当一个高优先级进程或交互式进程 发生跳跃时，整个系统的性能就会受到影响。

新调度器解决上述问题的方法是，基于每个 CPU 来分布时间片，并取消全局同步和重算循环。调度器使用了两个优先级数组，即活动数组和过期数组，可以通过指针来访问它们。活动数组中包含所有映射到某个 CPU 且时间片尚未用尽的任务。过期数组中包含时间片已经用尽的所有任务的有序列表。如果所有活动任务的时间片都已用尽，那么指向这两个数组的指针互换，包含准 备运行任务的过期数组成为活动数组，而空的活动数组成为包含过期任务的新数组。数组的索引存储在一个 64 位的位图中，所以很容易找到最高优先级的任务。

新调度器的主要优点包括：

◆ SMP 效率 如果有工作需要完成，所有处理器都会工作。

◆ 等待进程 没有进程需要长时间地等待处理器，也没有进程会无端地占用大量的 CPU 时间。

◆ SMP 进程映射 进程只映射到一个 CPU ，而且不会在 CPU 之间跳跃。

◆ 优先级 非重要任务的优先级低，反之亦然。

◆ 负载平衡 调度器会降低那些超出处理器负载能力的进程的优先级。

◆ 交互性能 即使在高负载的情况下，系统花费很长时间来响应鼠标点击或键盘输入的情况也不会再发生。

2 ．高效的调度程序

2.6 版内核中，进程调度经过重新编写，调度程序不需每次都扫描所有的任务，而是在一个任务变成就绪状态时将其放到一个名为“当前”的队列中。当进程调度程序运 行时，只选择队列中最有利的任务来执行。这样，调度可以在一个恒定的时间里完成。当任务执行时，它会得到一个时间段，或者在其转到另一线程之前得到一段时 间的处理器使用权。当时间段用完后，任务会被转移到另一个名为“过期”的队列中。在该队列中，任务会根据其优先级进行排序。

从某种意义上说，所有位于“当前”队列的任务都将被执行，并被转移到“过期”队列中。当这种事情发生时，队列就会进行切 换，原来的“过期”队列成为“当前”队列，而空的“当前”队列则变成“过期”队列。由于在新的“当前”队列中，任务已经被排列好，调度程序现在使用简单的 队列算法，即总是取当前队列的第一个任务进行执行。这个新过程要比老过程快得多。

3 ．新的同步措施

多进程应用程序有时需要共享一些资源，比如共享内存或设备。为了避免竞争的出现，程序员会使用一个名为互斥的功能来确保 同一时刻只有一个任务在使用资源。到目前为止， Linux 还是通过一个包含在内核中的系统调用来完成互斥的实现，并由该系统调用决定一个线程是等待还是继续执行。

Linux 2.6 内核支持 FUSM （ Fast User-Space Mutex ）。这个新功能会检查用户的空间，查看是否有等待的情况出现，并且只有在线程需要等待时才进行系统调用。这样当不需要等待时，就会避免不必要的系统调用， 以节约时间。该功能也使用优先级调度，以便在出现竞争时决定哪一个线程可以被执行。

测试报告

测试平台：

硬件：

2 AMD XP 2500+ / Intel PV 3G (HT支持)

2 DDR RAM 256M 333Mhz

2 硬盘 Maxtor 40G 7200rpm/s

2 主板 MSI KT4AV

2 100M 以太网卡

软件

2 GCC 3.4.2

2 Slackware 10.1

2 文件系统 ReiserFS

参考平台

FreeBSD5.3

比较对象；

2 kernel 2.4.29

2 kernel 2.6.10

2 FreeBSD 5.3

说明：

所有内核都根据平台属性重新编译

测试工具

2 lmbench 用于系统性能整体测试

2 forkbomb 进程压力测试

2 Netperf 网路性能测试

Linux 2.6 编译

首先获取最新的 kernel 代码

linux-2.6.10.tar.bz2

解压源代码

tar zjvf linux-2.6.10.tar.bz2

进行配置：

make xconfig

测试使用 SSH 客户端在字符界面下进行。

比较结果

内核的大小

根据机器的硬件状况重新编译了内核，编译的结果如下：（未压缩）

启动内存大小

系统启动后，开启了12路的VoIP网关程序。结果，内存的消耗状况如下，大家不要害怕，这还能称为嵌入式系统吗？

线程创建速度

pthread 线程创建测试， BSD 是绝对的赢家，几乎不需要时间

内存访问速度

内存访问测试，三者速度差多，整体来看 2.4 快于 bsd 快于 2.6

文件访问

文件访问速度 BSD>2.4>2.6

网络流量

网络速度： BSD 明显优势

socket 创建速度

socket 函数创建的时间： BSD 优于 2.6 优于 2.4

bind 函数访问时间

在小负载下，三者表现比较接近，时间是常数在大负载下 2.4.29 变慢

Here are some initial notes to help you understand the terminology and conventions used in this document:

• "bash$" and "bash#" are shell prompts, not commands to be typed.
• "host" means the machine you are building the ARM kernel on.
• "target" means the machine you are building the ARM kernel for.

1. Decide where to build your kernel

   Firstly, you need to decide where you are going to build your ARM Linux kernel. A good place to build the kernel is in your home directory, which we will refer to as $HOME thoughout this document. If you wish to use some other location, replace $HOME as appropriate.

   However, please note that building a kernel in /usr/src/linux is highly discouraged.

2. Deciding on a kernel version

   Firstly, you need to decide which version of the Linux kernel you wish to compile. Most people will want the latest stable kernel release. To help you identify a particular release, a system of version numbers is used by the kernel developers.

   For any kernel version x.y.z,

   • x - This is the major revision number
   • y - This is the minor revision number, where:
     Even numbers indicate "stable" kernel releases
     Odd numbers indicate "development" or "beta" kernel releases which may be less stable.
   • z - This is the patch level of the kernel

   This version number represents the main line kernel version.

   At the time of writing this document, the latest stable kernel on ARM is 2.6.6.

   Under the ARM kernel tree, you will find a suffix to the kernel version number: -rmkN, or -vrsN where 'N' is the patch release number. For instance, 2.4.26-vrs1. This indicates the version of the main ARM kernel patch which should be applied. (note: kernels later than 2.6.0-test2 do not require a -rmk or -vrs patch to be applied since ARM architecture support is already merged.)

   Other maintainers, such as Nicolas Pitre, may produce additional patches, and these will add an additional suffix to denote their version. Nicolas Pitre's patches add a -np suffix, eg 2.4.21-rmk2-np1.

   This means that 2.4.21-rmk2-np1 is based upon 2.4.21-rmk2, which in turn is based upon the 2.4.21 kernel. Therefore, to get the kernel source for 2.4.21-rmk2-np1, you need the 2.4.21 main line kernel source, the 2.4.21-rmk2 patch and the 2.4.21-rmk2-np1 patch.

   Therefore, if you need extra patches from other maintainers, you have to be careful to choose an appropriate kernel version. You will need to locate the maintainer patches first, and then work your way up through the version number towards the mainline kernel version.

3. Downloading the maintainer-specific patch.

   In some circumstances, you will need to patch the kernel with a maintainer specific patch. These patches add extra features or other device drivers which may be specific to various machines. However, as a general rule, maintainers forward upstream parts of their patches into the -rmk or -vrs trees as and when they are happy with the change.

   Please refer to the machine list for information concerning extra patches.

4. Downloading an ARM patch.

   (You only need this step if you are using a kernel prior to 2.6.0-test2. There are no -rmk or -vrs patches for later kernels.)

   You may need to download a kernel patch, which contains all the ARM specific updates for a particular kernel version. These can be found in ftp://ftp.arm.linux.org.uk/pub/armlinux/source/kernel-patches/. The kernel releases are separated out into directories corresponding to the major and minor version numbers of the kernel.

   The individual files are named patch-x.y.z-rmkN.gz or patch-x.y.z-vrsN.gz, where 'x', 'y', 'z' and 'N' are the version numbers mentioned above. You should select and download the latest patch for the kernel into the $HOME directory. This is the one which will have either the most features, or the most bug fixes in. You will need the version of the patch later when downloading the main kernel source.

   Note: Some files may be named (eg) pre-patch-x.y.z-rmkN.gz. These are alpha or beta patches, which are probably unstable. You should not use these unless you are sure that you know what you are doing, and you don't mind the target system being unstable. However, they are useful when new ideas need to be tested out.

   Note2: Some kernels are based on the Alan Cox series of kernels. These have names similar to patch-x.y.z-acm-rmkN.gz where x.y.z is Linus' version number and m is Alan's version number. In this case, you will need to obtain Alan Cox's corresponding patch from the kernel.org servers, in the directory /pub/linux/kernel/people/alan/linux-2.4/.

5. Downloading the main line kernel source

   A patch file on its own usually does not contain any compilable code. It is a machine-readable description of changes to make to a set of text files (in this case, the kernel source.) You need to obtain the main kernel source tree.

   The kernel source can be found on one of the kernel.org FTP sites. There are many sites scattered around the world, and are named according to a unified naming scheme. All sites start with 'ftp.' and end in '.kernel.org'. In the middle is placed a country identifier. For example:

   • ftp.uk.kernel.org
   • ftp.us.kernel.org
   • ftp.de.kernel.org

   and so forth. You can find out more information on these sites by looking at the main www.kernel.org site.

   Once you have selected a site, you need to find the kernel sources. They will be stored in the subdirectories of /pub/linux/kernel. Each kernel release is accompanied by several files:

   • linux-x.y.z.tar.gz
   • linux-x.y.z.tar.bz2
   • patch-x.y.z.gz
   • patch-x.y.z.bz2

   You will want to download the linux-x.y.z.tar.gz file, again into your $HOME directory. Again, you should look for a version which matches the version of the patch you obtained above. These files are large (about 14MB or more), so if you are on a slow connection, be prepared for it to take some time.

6. Unpacking the ARM kernel source

   Unpack the tar archive you downloaded above using:

   	bash$ cd $HOME
   	bash$ tar zxvf linux-x.y.z.tar.gz
   

   This will create a directory called linux or linux-x.y.z in your home directory. Change into the newly created directory and apply the patch files, eg:

   	bash$ cd linux-2.4.26
   	bash$ zcat ../patch-2.4.26-vrs1.gz | patch -p1
   

   The patches are heirarchial, so you need to apply them in the correct order. The patch files with more extensions depend on the ones with less extensions, so you need to apply, for example, the -rmk patch before the -rmk-np patch.

   The kernel source tree is now ready to be configured.

7. Configuration of the kernel build environment

   Normally, the kernel build system will build the kernel for the native machine architecture. This is not appropriate when cross compiling, so you will need to change two lines in the top level kernel Makefile. Examine the top level Makefile in an editor and find the definitions for ARCH and CROSS_COMPILE. On 2.4.x kernels, they will look like this:

   ARCH := $(shell uname -m | sed -e s/i.86/i386/ -e s/sun4u/sparc64/ -e s/arm.*/arm/ -e s/sa110/arm/)
   

   [...]

   CROSS_COMPILE   =
   

   and on 2.6.x kernels:

   ARCH            ?= $(SUBARCH)
   CROSS_COMPILE   ?=
   

   Edit these two lines to read:

   ARCH		?= arm
   CROSS_COMPILE	?= /usr/local/bin/arm-linux-
   

   replacing /usr/local/bin/arm-linux- with the path to your ARM Linux toolchain.

   This completes the configuration of the top level kernel makefile. The next step is to configure the kernel build to select the drivers that your platform requires.

   You may like to read linux/README and linux/Documentation/arm/README before proceeding. Both these files provide further useful information which may be specific to your kernel version.

8. Configuration of the kernel sources

   There are a range of 'make' targets which allow a set of defaults to be selected for the particular machine you are compiling the source for. The process is much simpler for 2.6 kernels.

   Configuration of 2.4 kernels

   For 2.4 kernels use <machinename>_config format, for example:
   • a5k_config
   • ebsa110_config
   • netwinder_config
   • rpc_config
   • assabet_config

   You should select one of these as the "basic" configuration as follows, and run make oldconfig immediately afterwards:

   	bash$ make netwinder_config
   	bash$ make oldconfig
   

   The oldconfig step will prompt you for any new configuration options which may have been added since the default machine configuration file was submitted. It is normally safe to say 'N' to these new options.

   Note: If you want to change the configuration via make xxx_config, please remove the file linux/.config immediately prior to executing this command.

   Configuration of 2.6 kernels

   For 2.6 kernels, the process is similar. Use <machinename>_defconfig to select the machine, eg:

   	bash$ make netwinder_defconfig
   

   In this case, there is no need to run a separate oldconfig step.

9. Compiling the kernel source

   If you are only installing the kernel source tree for other programs, then you have finished. If you want to compile up a new kernel, type the following commands:

   	bash$ make clean
   	bash$ make dep
   	bash$ make zImage
   	bash$ make modules
   

   The final two commands will actually compile the kernel and the kernel modules.

   Note: With 2.6 kernels, the make dep stage is not necessary.

10. Installing the kernel

    After the kernel has successfully compiled, you should have the kernel image, arch/arm/boot/zImage. What you do next depends if you are cross compiling or not.

    If you are cross compiling, goto the section "Installing a cross compiled kernel".

    If you are building natively (ie, for the target on the target), continue.

11. Installing a native kernel

    Since you are about to upgrade system files, you need to become 'root'. To do this, type:

    	bash$ su
    	Password:
    	bash#
    

    It is highly advisable to keep a backup of your current kernel and modules. What you need to do is machine dependent. Note that it is a good idea to always keep a known good previous version of the kernel and modules in case you need to back down to a previous version.

    The following is given as an example (for a 2.4.3-rmk1 kernel):

    	bash# cd /lib/modules
    	bash# mv 2.4.3-rmk1 2.4.3-rmk1.old
    	bash# cd /boot
    	bash# mv vmlinuz vmlinuz.bak
    	bash# mv System.map System.map.bak
    	bash#
    

    Now, install the new kernel modules:

    	bash# cd $HOME/linux
    	bash# make modules_install
    	bash#
    

    This will copy the modules into the /lib/modules/x.y.z directory. Next, install the kernel image (normally into /boot):

    	bash# cd /boot
    	bash# cat $HOME/linux/arch/arm/boot/zImage >vmlinuz
    	bash# cp $HOME/linux/System.map .
    	bash#
    

    Note that the command to copy the new kernel image is cat and is not the usual cp. Unix traditionally will not allocate space on the filesystem to sections of files containing zero data, but instead creates "holes" in the file. Some kernel loaders do not understand files with holes in, and therefore using cat in this way ensures that this does not happen.

12. Running loadmap

    Loadmap is part of the Linux loader on Acorn machines, as well as EBSA285 machines using EBSA285BIOS with an IDE disk. For other machines, please refer to the documentation for your machine.

    Edit the loader configuration file /etc/boot.conf so that you can boot either the vmlinuz.bak or vmlinuz images. If you place the vmlinuz kernel first, then this will be the default kernel which the kernel loader will use.

    More information can be found by typing man boot.conf.

    Run the boot loader map utility:

    	bash# loadmap -v
    	bash#
    

    to update the maps.

    You have finished, and are now ready to reboot your machine and try out your new kernel! If you experience problems, please go to the "Problems" step below.

13. Installing a cross compiled kernel

    Kernel modules are installed into the /lib/modules/x.y.z directory on the target system, though this will normally be a different directory on the host system. Where this directory is depends on your setup, but we will call it $TARGETDIR.

    Install the modules into $TARGETDIR as follows:

    	bash$ make modules_install INSTALL_MOD_PATH=$TARGETDIR
    	bash$
    

    This will place the modules into the $TARGETDIR/lib/modules/x.y.z directory on the host, which can then be placed into an suitable filesystem, or transferred to the target machine. Please also note that you must not install these kernel modules into the hosts root filesystem (eg by omitting INSTALL_MOD_PATH or giving $TARGETDIR as "/"), since they are incompatible with your host kernel and therefore may leave you with an unbootable host system.

    The kernel will be available in $HOME/linux/arch/arm/boot/zImage and the kernel symbol information in $HOME/linux/System.map. Exactly how do install this is outside the scope of this document.

    It is important that you keep the System.map file safe - it contains the symbolic information for this kernel, which will be required if you need to debug or report a problem.

14. Reporting Problems

    Please follow the REPORTING-BUGS guide in the kernel source tree. However, please use the linux-arm-kernel mailing list to report problems, rather than the linux-kernel mailing list.

一、从网上将Linux内核源代码下载到本机上，并将其解压：
#tar jxf linux-2.6.11.1.tar.bz2
二、打开内核顶层目录中的Makefile文件，这个文件中需要修改的内容包括以下两个方面。
（1）指定目标平台。
 移植前：
  ARCH      ?= $(SUBARCH)
 移植后：
 ARCH            :=arm
（2）指定交叉编译器。
  移植前：
 CROSS_COMPILE  ?=
 移植后：
 CROSS_COMPILE   :=/opt/crosstool/arm-s3c2410-linux-gnu/gcc-3.3.4-glibc-2.3.3/bin/arm-s3c2410-linux-gnu-
注：这里假设编译器就放在本机的那个目录下。
三、添加并修改驱动程序源代码，这涉及到以下几个方面。
（1）、将开发板配带的LCD驱动程序s3c2400fb.c、s3c2400fb.h源程序放到drivers/video/目录下，并修改名字为s3c2410fb.c\s3c2400fb.h。
#cp s3c2400fb.c . drivers/video/s3c2410fb.c
（2）、 在s3c2410fb.c驱动程序里面添加：sbc_gpio_con_set()、sbc_gpio_pullup_set()、 sbc_gpio_function_set()的声明以及实现代码用以替代2.4.18代码中的write_gpio_bit()、 set_gpio_ctrl()函数，因为在2.4.18中这两个函数都是用指针的方式对CPU寄存器进行设置，而在2.6.11的驱动程序里面用了 __raw_writel()的方式对寄存器设置进行了封装。
在驱动程序移植过程中由于是基于S3C2400的驱动，所以主要的修改工作就是根据所用开发板的硬件修改相应的寄存器的设置。
主 要的修改有：s3c2410fb_mach_info结构，这个结果主要定义了所用显示屏的一些信息，如时钟、大小等；修改 c2400fb_activate_var函数中关于寄存器的设置，这个函数涉及到了S3C2410 LCD控制器的有关设置，这些寄存器的设置要根据所用的屏幕（TFT/CSTN）来进行设置；修改 s3c2400fb_set_controller_regs和s3c2400fb_lcd_init函数，这个函数涉及到了CPU与LCD的物理连接， 要根据LCD与CPU的具体连接来设置各个CPIO寄存器。
注：具体修改详见驱动程序。
（3）、修改arch/arm/mach-s3c2410/s3c2410.c，在s3c2410_iodesc结构中添加：IODESC_ENT(LCD)
注：以上添加的语句就是为了将CPU的LCD寄存器的物理地址映射到所指向的虚拟地址上去，上面的结构还定义了虚拟地址所占用的区间，并指定了该区间所指向的域（的属性）。
（4）、修改drivers/video目录下的Kconfig文件，在最后添加如下内容：
config FB_S3C2410
 tristate "S3C2410 LCD support"
 depends on FB && ARM && ARCH_S3C2410
 help
   This is a framebuffer device for the S3C2410 LCD Controller.   If you plan to use the LCD display with your S3C2410 system, say   Y here.
（5）、修改drivers/video目录下的Makefile文件，在最后添加如下内容:
obj-$(CONFIG_FB_S3C2410)        += s3c2410fb.o cfbfillrect.o cfbcopyarea.o cfbimgblt.o
四、配置、编译内核。在内核顶层目录当中键入：
  #make smdk2410_defconfig
由于2.6的内核默认就支持了S3C2410，所以就有一个默认的内核配置文件。里面只是包括了一个简单的配置，要使LCD驱动编译进内核，还要进行手工配置。
#make menuconfig

  Graphics support  --->    
       [*] Support for frame buffer devices
     [*] S3C2410 LCD support(BASED ON S3C2400)
将刚才添加的LCD驱动程序静态添加到内核当中。
最后进行内核编译。
#make
然后将镜像下载到开发板中去.
而且在LCD显示屏上的左上角会显示一个小企鹅的图标。查看设备文件。
[root@fa /]# ls -al /dev/fb/0
由此可见，LCD已经成功驱动，要测试驱动程序可以用 自己写（见附件test.c）在显示屏上显示任意颜色的线条。
问题解析
在LCD驱动程序移植的过程中，出现的问题主要就是由于寄存器设置不正确而造成的问题。
在 对驱动程序进行了函数替代以及改写了一些函数之后，将驱动程序编译进内核里，内核可以正确的编译连接并生成镜像文件，把镜像文件下载到开发板上，可以看到 drivers/video目录下看到系统注册的一个设备文件，但是在系统启动之后就是无法看见小企鹅的图标并且用测试程序去测试，LCD屏幕上也无法显 示任何有色的线条。通过多次查阅源代码，才发现原来就是CPU有关LCD的8个寄存器的设置以及对GPC和GPD寄存器的设置不正确。后来对这几个寄存器 进行了正确的设置就可以在系统启动之后看到小企鹅的图标。由于屏幕的背景是蓝色的，所以该图标的颜色显示不正确，但是用自己写的测试程序去画设置好的颜色 的线条，在屏幕上总能正确的显示出来，所以至于这个屏幕的颜色问题至今尚未解决。

/*add by lfc*/
include
include
include
include
/*end add*/

/**********************add by lfc*************************************/
static struct s3c2410_hcd_info usb_sbc2410_info = {
       .port[0]        = {
               .flags  = S3C_HCDFLG_USED
       }
};

int usb_sbc2410_init(void)
{
unsigned long upllvalue = (0x78<<12)|(0x02<<4)|(0x03);
printk("USB Control, (c) 2006 sbc2410\n");
s3c_device_usb.dev.platform_data = &usb_sbc2410_info;
while(upllvalue!=__raw_readl(S3C2410_UPLLCON))
{
__raw_writel(upllvalue,S3C2410_UPLLCON);
mdelay(1);
}
return 0;
}

/***************************end add**********************/

static void __init smdk2410_map_io(void)
{
s3c24xx_init_io(smdk2410_iodesc, ARRAY_SIZE(smdk2410_iodesc));
s3c24xx_init_clocks(0);
s3c24xx_init_uarts(smdk2410_uartcfgs, ARRAY_SIZE(smdk2410_uartcfgs));
s3c24xx_set_board(&smdk2410_board);
/*************************add by lfc****************************/
       usb_sbc2410_init();
/*************************end add*******************************/
}

上面的修改其实也参考了这个牛贴一下，里面有大虾们对USB驱动移植的讨论，还不错：
http://www.linuxforum.net/forum/showflat.php?Cat=&Board=embedded&Number=556915&page=0&view=collapsed&sb=5&o=0&fpart=

其实到了这里，要修改的代码已经修改完了，比添加Nand flash的支持修改的地方还要少^_^，不过我一直以为还没修改好，最后发现原来是没配置好~_~

二、内核配置
下面说一下郁闷了我好一阵子的内核配置（支持USB）问题，这个就比Nand flash的配置要复杂多了。
１、让内核支持热插拔
│                General setup  --->  
 │ │[*] Support for hot-pluggable devices

２、USB驱动设置，可能有些不选也行，不过没时间去试，至于为什么要选这些选项的话可以看一下这个贴（Linux下的硬件驱动——USB设备）：
http://www-128.ibm.com/developerworks/cn/linux/l-usb/index1.html

 │ │                Device Drivers  --->
│ │              Generic Driver Options  --->          
│<*> Hotplug firmware loading support    
 │ │              Block devices  --->  
 │ │              <*> Low Performance USB Block driver  
 │ │              SCSI device support  --->  
 │ │  <*>   SCSI generic support  
│ │  [*]   Probe all LUNs on each SCSI device    
 │ │              USB support  --->        
 │ │<*> Support for Host-side USB    
│ │[*]   USB device filesystem
 │ │<*>   OHCI HCD support  
│ │<*>   USB Mass Storage support
 │ │[*]   USB Monitor

３、加入了MSDOS fs和VFAT fs的支持。

 │ │                File systems  --->      
 │ │        DOS/FAT/NT Filesystems  --->  
 │ ┌─────────────────────────────────────────────────────────────────────┐ │
 │ │                 <*> MSDOS fs support                                │ │
 │ │                 <*> VFAT (Windows-95) fs support                    │ │
 │ │                 (936) Default codepage for FAT                      │ │
 │ │                 (cp936) Default iocharset for FAT                   │ │
 │ │                 < > NTFS file system support

做完这些后，插入u盘后，内核应该可以识别到u盘，出现：
usb 1-1: new full speed USB device using s3c2410-ohci and address 3
ub(1.3): GetMaxLUN returned 0, using 1 LUNs

但是，还有下面一句出错提示：
/dev/ub/a: unknown partition table

再次查看了贴子上大虾们的讨论，提到：“使能CONFIG_MSDOS_PARTITION选项”，再仔细查找，发现配置选项如下：
│ │                File systems  --->
│ │                Partition Types  --->  
 │ │     [*]   PC BIOS (MSDOS partition tables) support
加上这个后应该就可以挂载usb上的MSDOS分区了

以下是我的内核插入u盘后的提示信息：
usb 1-1: new full speed USB device using s3c2410-ohci and 2
ub(1.2): GetMaxLUN returned 0, using 1 LUNs
/dev/ub/a: p1
表示usb设备已经挂载到/dev/ub/a/part1设备文件下

4.加入中文字体库（可惜在我的板上还是没能正常显示中文~_~，知道的朋友麻烦告诉我一声，大家一起探讨）
 │ │        Native Language Support  --->    
 │ │<*>   Simplified Chinese charset (CP936, GB2312)  
 │ │<*>   NLS UTF8

以下是挂载usb设备后的显示：
[root@luofuchong /]# mount -t vfat -o iocharset=cp936 /dev/ub/a/part1 /mnt
[root@luofuchong /]# ls /mnt
cramfs-1.1.tar.gz        netkit-base-0.17.tar.gz  thttpd-2.25b.tar.gz
lfc                      settings.dat             . . I. ..  . .txt

三、一点心得。

如果想知道内核有没有识别出u盘的话可以执行命令：cat /proc/partitions ，看看插入USB前后分区信息有什么不同就知道了。

另外，我在贴上看到其它大虾移植了USB驱动的内核，在插入U盘后内核都把它当成SCSI设备来处理的，不过在我这里却没有，这点我倒不是很明白，难道是我u盘的问题？

还 有就是，usb设备的挂载点比较特别，在我移植的系统中是：/dev/ub/a/part1。刚开始我不知道，以为/dev/ub/a就是了，结果当然挂 载不了，差点就重编内核了，所以如果内核提示挂载usb设备成功的话，最好进入对应的目录仔细看清楚。如果是当成SCSI设备的话挂载点就在 /dev/scsi/host0/bus0/target0/lun0之类吧。其实插入u盘的时候都有提示，自己看着办吧。

还 有一个问题，为了统一起见，一般都会新建一个/dev/sda1的链接指向usb设备的挂载点的，但是我的内核是采用devfs的，文件系统的/dev目 录空空如也，而且/dev/ub/a/part1是插入u盘后才有的挂载点，那请问我应该怎样去新建这个链接呢？希望各位大虾知道的话可以告知我，感激不 尽！

搞定了这个问题，没有加入对应文件系统的language编码支持。
配置如下：
File systems -->
DOS/FAT/NT Filesystems --->

TigerZ(tigerz@yeah.net)
http://emblinux.org/

1. 分析环境

    kernel: 2.6.10
    board: SMDK2410 1.32, 64M SDRAM, 128M SM卡

2. head.S
*/

/*
 * linux/arch/arm/kernel/head.S
 *
 *  Copyright (C) 1994-2002 Russell King
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 *  Kernel startup code for all 32-bit CPUs
 */
#include <linux/config.h>
#include <linux/linkage.h>
#include <linux/init.h>

#include <asm/assembler.h>
#include <asm/mach-types.h>
#include <asm/procinfo.h>
#include <asm/ptrace.h>
#include <asm/constants.h>

#ifndef CONFIG_XIP_KERNEL /* 我在的平台, 这个宏没有定义 */
/*
 * We place the page tables 16K below TEXTADDR.  Therefore, we must make sure
 * that TEXTADDR is correctly set.  Currently, we expect the least significant
 * 16 bits to be 0x8000, but we could probably relax this restriction to
 * TEXTADDR >= PAGE_OFFSET + 0x4000
 *
 * 页表放在比TEXTADDR低16K的地方, 所以我们必须要确认TEXTADDR被正确设定. 目前,
 * 我们希望低16位为0x8000, 不过我们可以放松这个限制为
 * TEXTADDR >= PAGE_OFFSET + 0x4000
 *
 * Note that swapper_pg_dir is the virtual address of the page tables, and
 * pgtbl gives us a position-independent reference to these tables.  We can
 * do this because stext == TEXTADDR
 *
 * 注意swapper_pg_dir是页表的虚拟地址, pgtbl给我们一个位置无关的页表地址, 这是
 * 因为stext == TEXTADDR.
 */
#if (TEXTADDR & 0xffff) != 0x8000
    #error TEXTADDR must start at 0xXXXX8000
#endif

    /* swapper_pg_dir = 0x30008000 - 0x4000 */
    .globl swapper_pg_dir
    .equ    swapper_pg_dir, TEXTADDR - 0x4000

    /* rd = stext - 0x4000, 这里stext == TEXTADDR */
    /* adr指令是在pc值上+/-一个标号的偏移得到的, 所以得到的地址只跟pc和标号到
     * pc的偏移相关, 跟编译地址无关. 在MMU打开前, 代码要是地址无关的, 会经常
     * 用到adr.
     */
    .macro pgtbl, rd, phys
    adr     \rd, stext
    sub     \rd, \rd, #0x4000
    .endm
#else
/*
* XIP Kernel:
*
* We place the page tables 16K below DATAADDR.  Therefore, we must make sure
* that DATAADDR is correctly set.  Currently, we expect the least significant
* 16 bits to be 0x8000, but we could probably relax this restriction to
* DATAADDR >= PAGE_OFFSET + 0x4000
*
* Note that pgtbl is meant to return the physical address of swapper_pg_dir.
* We can't make it relative to the kernel position in this case since
* the kernel can physically be anywhere.
*/
#if (DATAADDR & 0xffff) != 0x8000
#error DATAADDR must start at 0xXXXX8000
#endif

.globl swapper_pg_dir
.equ swapper_pg_dir, DATAADDR - 0x4000

.macro pgtbl, rd, phys
ldr \rd, =((DATAADDR - 0x4000) - VIRT_OFFSET)
add \rd, \rd, \phys
.endm
#endif

/*
 * Kernel startup entry point.
 * ---------------------------
 * Kernel的启动入口.
 *
 * This is normally called from the decompressor code.  The requirements
 * are: MMU = off, D-cache = off, I-cache = dont care, r0 = 0,
 * r1 = machine nr.
 *
 * 这里一般由解压缩代码调用. 它需要: MMU = off, D-cache = off,
 * I-cache = 不关心, r0 = 0, r1 = 机器号.
 *
 * This code is mostly position independent, so if you link the kernel at
 * 0xc0008000, you call this at __pa(0xc0008000).
 *
 * 这里的代码通常是位置无关的, 所以如果你在0xc0008000链接kernel, 直接调用
 * __pa(0xc0008000).
 *
 * See linux/arch/arm/tools/mach-types for the complete list of machine
 * numbers for r1.
 *
 * 在linux/arch/arm/tools/mach-types里查看机器号r1的完整列表.
 *
 * We're trying to keep crap to a minimum; DO NOT add any machine specific
 * crap here - that's what the boot loader (or in extreme, well justified
 * circumstances, zImage) is for.
 *
 */
    __INIT
    .type   stext, #function
ENTRY(stext)
    mov     r12, r0
    mov     r0, #PSR_F_BIT | PSR_I_BIT | MODE_SVC   @ make sure svc mode
                                                /* 确认是SVC模式 */
    msr     cpsr_c, r0          @ and all irqs disabled
                            /* 关闭所有irq */
    bl      __lookup_processor_type     /* 查看处理器类型 */
    teq     r10, #0             @ invalid processor?
                            /* 无效的处理器? */
    moveq r0, #'p'        @ yes, error 'p'
                            /* 如果是, 错误码'p' */
    beq     __error
    bl      __lookup_architecture_type /* 查看体系类型 */
    teq     r7, #0              @ invalid architecture?
                            /* 无效体系? */
    moveq r0, #'a'        @ yes, error 'a'
                            /* 如果是, 错误码'a' */
    beq     __error
    bl      __create_page_tables    /* 建立页表 */

    /*
     * The following calls CPU specific code in a position independent
     * manner.  See arch/arm/mm/proc-*.S for details.  r10 = base of
     * xxx_proc_info structure selected by __lookup_architecture_type
     * above.  On return, the CPU will be ready for the MMU to be
     * turned on, and r0 will hold the CPU control register value.
     *
     * 下面的代码按位置无关的方式调用特定的CPU代码, 详细信息查看
     * arch/arm/mm/proc-*.S. r0 = xxx_proc_info结构起始地址, 该结构由上面
     * 的__lookup_architecture_type选择. 在返回时, CPU已经准备好打开MMU,
     * r0将保存CPU控制寄存器的值.
     */
    adr     lr, __turn_mmu_on       @ return (PIC) address
                                    /* 调用完下面的__arm920_setup后返回到
                                       __turn_mmu_on */
    add     pc, r10, #12            /* 调用__arm920_setup , 详见
                                       arch/arm/mm/proc-arm920.S */

    .type   __switch_data, %object
__switch_data:
    .long   __mmap_switched
    .long   __data_loc              @ r2
    .long   __data_start            @ r3
    .long   __bss_start             @ r4
    .long   _end                    @ r5
    .long   processor_id            @ r6
    .long   __machine_arch_type     @ r7
    .long   cr_alignment            @ r8
    .long   init_thread_union+8192  @ sp

    /*
     * Enable the MMU.  This completely changes the structure of the visible
     * memory space.  You will not be able to trace execution through this.
     * If you have an enquiry about this, *please* check the linux-arm-kernel
     * mailing list archives BEFORE sending another post to the list.
     *
     * 打开MMU. 这将完全改变可见存储空间的结构, 你不能跟踪运行情况.
     * 如果你有疑问, 请先查看linux-arm-kernel邮件列表, 在你发邮件到这个列表前.
     */
    .align 5
    .type   __turn_mmu_on, %function
__turn_mmu_on:
    ldr     lr, __switch_data                   /* 完成后跳到__switch_data偏移0存放的地址,
                                                   即__mmap_switched */
    #ifdef CONFIG_ALIGNMENT_TRAP
    orr     r0, r0, #2                          @ ...........A.
                                                /* 访问非对齐地址产生一个TRAP */
    #endif
    mcr     p15, 0, r0, c1, c0, 0               @ write control reg
    mrc     p15, 0, r3, c0, c0, 0               @ read id reg
    mov     r3, r3
    mov     r3, r3
    mov     pc, lr

/*
 * The following fragment of code is executed with the MMU on, and uses
 * absolute addresses; this is not position independent.
 *
 * 下面的代码在MMU打开的情况下运行, 是绝对地址, 不是位置无关的.
 *  r0  = processor control register
 *  r1  = machine ID
 *  r9  = processor ID
 *  r12 = value of r0 when kernel was called (currently always zero)
 *
 * 这里主要是为调用C函数start_kernel做准备. 在调用这部分代码前, 我们必须
 * 打开MMU, 因为kernel的位置相关代码是要以0xc0008000为起始地址的, 所以在这
 * 之前, 我们建立了页表, 并打开MMU.
 */
    .align 5
__mmap_switched:
    adr         r2, __switch_data + 4
    ldmia       r2, {r2, r3, r4, r5, r6, r7, r8, sp}

    cmp         r2, r3              @ Copy data segment if needed
1:  cmpne       r3, r4
    ldrne       fp, [r2], #4
    strne       fp, [r3], #4
    bne         1b

    mov         fp, #0              @ Clear BSS (and zero fp)
1:  cmp         r4, r5
    strcc       fp, [r4],#4
    bcc         1b

    str         r9, [r6]   @ Save processor ID
    str         r1, [r7]   @ Save machine type
    bic         r2, r0, #2   @ Clear 'A' bit
    stmia       r8, {r0, r2}   @ Save control register values
    b           start_kernel

/*
 * Setup the initial page tables.  We only setup the barest
 * amount which are required to get the kernel running, which
 * generally means mapping in the kernel code.
 *
 * 设置初始化页表, 我们只设置kernel运行所需少量内存, 通常就是
 * 映射kernel的代码.
 *
 * r5 = physical address of start of RAM
 * r6 = physical IO address
 * r7 = byte offset into page tables for IO
 * r8 = page table flags
 */
__create_page_tables:
        /* 取页表地址到r4, 这里r4 = 0x30004000 */
        pgtbl r4, r5                          @ page table address

        /*
         * Clear the 16K level 1 swapper page table
         *
         * 清空页表
         */
        mov     r0, r4
        mov r3, #0
        add r2, r0, #0x4000
1: str r3, [r0], #4
        str r3, [r0], #4
        str r3, [r0], #4
        str r3, [r0], #4
        teq r0, r2
        bne 1b

        /*
         * Create identity mapping for first MB of kernel to
         * cater for the MMU enable.  This identity mapping
         * will be removed by paging_init().  We use our current program
         * counter to determine corresponding section base address.\
         *
         * kernel的第1M建立等价映射, 为打开MMU做准备. 这个等价映射将在
         * paging_init()中移除. 我们用pc来确定对应的段地址.
         */
        mov r2, pc, lsr #20   @ start of kernel section
        add r3, r8, r2, lsl #20  @ flags + kernel base (flags = 0x00000c1e)
        str r3, [r4, r2, lsl #2]  @ identity mapping
        /*
         *           r4           +  (pc >> 20) << 2
         * 31                   14 13           2 1 0
         * -------------------------------------------
         * |   Translatioin base  | Table index  |0|0|
         * -------------------------------------------
         * 这一个表项把kernel section的虚地址和实地址等同起来.
         * r3 = 0x00000c1e + 0x30000000 = 0x30000c1e
         * r4 = 0x30004000
         * r2 >> 18 = 0x30000000 >> 18 = 0xc00
         * [0x30004000 + 0xc00] = 0x30000c1e
         */

        /*
         * Now setup the pagetables for our kernel direct
         * mapped region.  We round TEXTADDR down to the
         * nearest megabyte boundary.  It is assumed that
         * the kernel fits within 4 contigous 1MB sections.
         *
         * 现在为kernel设置页表, 把TEXTADDR完整成MB, 这里假设
         * kernel在4个连续的1MB段内.
         */
        /* TEXTADDR = 0xc0000000 */
        add r0, r4,  #(TEXTADDR & 0xff000000) >> 18 @ start of kernel
        /* r0 = 0x30004000 + 0x3000 */
        str r3, [r0, #(TEXTADDR & 0x00f00000) >> 18]!
        /* [0x30004000 + 0x3000] = 0x30000c1e */
        /*
         * add r0, r4, #(TEXTADDR & 0xfff00000) >> 18
         * str r3, [r0]
         * 上2行的意思同这2行相同, 为什么不这样做?
         */
        add r3, r3, #1 << 20
        str r3, [r0, #4]!   @ KERNEL + 1MB
        /* [0x30004000 + 0x3004] = 0x30100c1e */
        add r3, r3, #1 << 20
        str r3, [r0, #4]!   @ KERNEL + 2MB
        /* [0x30004000 + 0x3008] = 0x30200c1e */
        add r3, r3, #1 << 20
        str r3, [r0, #4]   @ KERNEL + 3MB
        /* [0x30004000 + 0x300c] = 0x30300c1e */

        /*
         * Then map first 1MB of ram in case it contains our boot params.
         *
         * 因为RAM的第1MB存放有boot参数, 所以也需要映射. (当前boot参数所在
         * 的段与前面pc值所在段相等, 但这不是一定的.
         */
        add r0, r4, #VIRT_OFFSET >> 18
        add r2, r5, r8
        str r2, [r0]

/* 下面代码略过 */
#ifdef CONFIG_XIP_KERNEL
/*
* Map some ram to cover our .data and .bss areas.
* Mapping 3MB should be plenty.
*/
sub r3, r4, r5
mov r3, r3, lsr #20
add r0, r0, r3, lsl #2
add r2, r2, r3, lsl #20
str r2, [r0], #4
add r2, r2, #(1 << 20)
str r2, [r0], #4
add r2, r2, #(1 << 20)
str r2, [r0]
#endif

bic r8, r8, #0x0c   @ turn off cacheable
@ and bufferable bits
#ifdef CONFIG_DEBUG_LL
/*
* Map in IO space for serial debugging.
* This allows debug messages to be output
* via a serial console before paging_init.
*/
add r0, r4, r7
rsb r3, r7, #0x4000   @ PTRS_PER_PGD*sizeof(long)
cmp r3, #0x0800
addge r2, r0, #0x0800
addlt r2, r0, r3
orr r3, r6, r8
1: str r3, [r0], #4
add r3, r3, #1 << 20
teq r0, r2
bne 1b
#if defined(CONFIG_ARCH_NETWINDER) || defined(CONFIG_ARCH_CATS)
/*
* If we're using the NetWinder, we need to map in
* the 16550-type serial port for the debug messages
*/
teq r1, #MACH_TYPE_NETWINDER
teqne r1, #MACH_TYPE_CATS
bne 1f
add r0, r4, #0x3fc0   @ ff000000
mov r3, #0x7c000000
orr r3, r3, r8
str r3, [r0], #4
add r3, r3, #1 << 20
str r3, [r0], #4
1:
#endif
#endif
#ifdef CONFIG_ARCH_RPC
/*
* Map in screen at 0x02000000 & SCREEN2_BASE
* Similar reasons here - for debug.  This is
* only for Acorn RiscPC architectures.
*/
add r0, r4, #0x80   @ 02000000
mov r3, #0x02000000
orr r3, r3, r8
str r3, [r0]
add r0, r4, #0x3600   @ d8000000
str r3, [r0]
#endif
        /* 返回 */
        mov pc, lr
        .ltorg

/*
 * Exception handling.  Something went wrong and we can't proceed.  We
 * ought to tell the user, but since we don't have any guarantee that
 * we're even running on the right architecture, we do virtually nothing.
 *
 * 异常处理. 一些东西错了就不能继续, 我们应该告诉用户, 但因为我们甚至不能
 * 保证运行在正确的体系上, 我们实际在做无用功.
 *
 * r0 = ascii error character:
 * a = invalid architecture
 * p = invalid processor
 * i = invalid calling convention
 *
 * Generally, only serious errors cause this.
 */
__error:
        #ifdef CONFIG_DEBUG_LL
        mov r8, r0    @ preserve r0
        adr r0, err_str
        bl printascii
        mov r0, r8
        bl printch
        #endif

#ifdef CONFIG_ARCH_RPC
/*
* Turn the screen red on a error - RiscPC only.
*/
mov r0, #0x02000000
mov r3, #0x11
orr r3, r3, r3, lsl #8
orr r3, r3, r3, lsl #16
str r3, [r0], #4
str r3, [r0], #4
str r3, [r0], #4
str r3, [r0], #4
#endif

1: mov r0, r0
        b 1b

#ifdef CONFIG_DEBUG_LL
err_str:
        .asciz "\nError: "
        .align
#endif

/*
 * Read processor ID register (CP#15, CR0), and look up in the linker-built
 * supported processor list.  Note that we can't use the absolute addresses
 * for the __proc_info lists since we aren't running with the MMU on
 * (and therefore, we are not in the correct address space).  We have to
 * calculate the offset.
 *
 * 读取处理器ID寄存器(CP#15, CR0), 在链接时建立的已支持处理器列表中查找.
 * 注意, 我们不能使用__proc_info的绝对地址, 因为我们还没有运行MMU,
 * (因此, 我们不在正确的地址空间). 我们必须计算偏移.
 *
 * Returns:
 * r5, r6, r7 corrupted
 * r8  = page table flags
 * r9  = processor ID
 * r10 = pointer to processor structure
 */
__lookup_processor_type:
        adr r5, 2f                          /* 取2f的相对地址 */
        ldmia r5, {r7, r9, r10}               /* r7 = __proc_info_end,
                                                   r9 = __proc_info_begin,
                                                   r10 = 2 */
        sub r5, r5, r10   @ convert addresses
                                                /* r5 = 2的相对地址 - 2的绝对地址 */
        add r7, r7, r5   @ to our address space
                                                /* r7 += r5, 把r7从绝对地址转化为
                                                   相对地址 */
        add r10, r9, r5                     /* 绝对转相对 */
        mrc p15, 0, r9, c0, c0  @ get processor id
1: ldmia r10, {r5, r6, r8}  @ value, mask, mmuflags
        and r6, r6, r9   @ mask wanted bits
        teq r5, r6
        moveq pc, lr
        add r10, r10, #PROC_INFO_SZ  @ sizeof(proc_info_list)
        cmp r10, r7
        blt 1b
        mov r10, #0    @ unknown processor
        mov pc, lr

        /*
         * Look in include/asm-arm/procinfo.h and arch/arm/kernel/arch.[ch] for
         * more information about the __proc_info and __arch_info structures.
         */
2: .long __proc_info_end
        .long __proc_info_begin
        .long 2b
        .long __arch_info_begin
        .long __arch_info_end

/*
 * Lookup machine architecture in the linker-build list of architectures.
 * Note that we can't use the absolute addresses for the __arch_info
 * lists since we aren't running with the MMU on (and therefore, we are
 * not in the correct address space).  We have to calculate the offset.
 *
 * 在链接时建立的机器列表中查找机器结构. 注意我们不能使用__arch_info的绝对地址,
 * 因为我们没有打开MMU(因此, 我们不在正确的地址空间). 我们必须计算偏移.
 *
 *  r1 = machine architecture number
 * Returns:
 *  r2, r3, r4 corrupted
 *  r5 = physical start address of RAM
 *  r6 = physical address of IO
 *  r7 = byte offset into page tables for IO
 */
__lookup_architecture_type:
        adr r4, 2b                          /* 这里的做法同__lookup_processor_type */
        ldmia r4, {r2, r3, r5, r6, r7} @ throw away r2, r3
        sub r5, r4, r5   @ convert addresses
        add r4, r6, r5   @ to our address space
        add r7, r7, r5
1: ldr r5, [r4]   @ get machine type
        teq r5, r1    @ matches loader number?
        beq 2f    @ found
        add r4, r4, #SIZEOF_MACHINE_DESC @ next machine_desc
        cmp r4, r7
        blt 1b
        mov r7, #0    @ unknown architecture
        mov pc, lr
2: ldmib r4, {r5, r6, r7}  @ found, get results
        mov pc, lr

此文章是关于嵌入式LINUX的

编译内核 /*linux-2.6.15*/
-------------
进入内核文件夹

打补丁使其支持at91rm9200
#zcat ../2.6.15-at91.patch.gz | patch -p1

编辑Makefile
ARCH            ?= $(SUBARCH)
CROSS_COMPILE   ?=
变为
ARCH  ?= arm
CROSS_COMPILE ?= /usr/local/eldk/usr/bin/arm-linux-
保存

编辑include/config/cmdline.h /*如果你的ramdisk在3M之内就跳过这一系列操作*/
#define CONFIG_CMDLINE "mem=32M console=ttyS0,115200 initrd=0x20410000,3145728 root=/dev/ram0 rw"
mem为你的sdmem大小，initrd为你的ramdisk加载地址，ramdisk大小，和加载设备。改为你需要的。
#define CONFIG_CMDLINE "mem=32M console=ttyS0,115200 initrd=0x20410000,4096000 root=/dev/ram0 rw"
保存

编辑include/linux/autoconf.h里的CMDLINE
同include/config/cmdline.h
保存

#make at91rm9200dk_defconfig

编辑.config
CONFIG_CMDLINE="mem=32M console=ttyS0,115200 initrd=0x20410000,3145728 root=/dev/ram0 rw"
同include/config/cmdline.h
保存

#make clean
#make zImage
#make modules

#mkdir images
#cp arch/arm/boot/zImage images/zImage-2.6.15
#cp vmlinux images/vmlinux-2.6.15
#cp System.map images/System.map-2.6.15
#cp .config images/2.6.15.config

#make INSTALL_MOD_PATH=images/modules-2.6.15 modules_install
copy busybox/examples 下的depmod.pl到内核文件夹
#./depmod.pl -b images/modules-2.6.15/lib/modules -k vmlinux

配置busybox /*busybox-1.1.1*/
--------------
#make menuconfig

下面是需要编译进busybox的功能选项,其他的可以根据需要自选。
General Configuration应该选的选项
Show verbose applet usage messages
Runtime SUID/SGID configuration via /etc/busybox.conf

Build Options
----------如果选用glibc则不选------
Build BusyBox as a static binary (no shared libs)
这个选项是一定要选择的,这样才能把busybox编译成静态链接的可执行文件,运行时才独立于其他函数库。否则必需要其他库文件才能运行,在单一个linux内核不能使他正常工作。
------------------------------------
选择交叉编译环境

Installation Options
Don't use /usr
这个选项也一定要选,否则make install 后busybox将安装在原系统的/usr下,这将覆盖掉系统原有的命令。选择这个选项后,make install后会在busybox目录下生成一个叫_install的目录,里面有busybox和指向他的链接。

其他选项都是一些linux基本命令选项,自己需要哪些命令就编译进去就可以了。

配置好后退出并保存。

4,编译并安装busybox

#make
#make install

编译好后在busybox目录下生成子目录_install,里面的内容:
drwxr-xr-x   2 root root     4096 2006-03-30 00:50 bin
drwxr-xr-x   2 root root     4096 2006-03-30 00:50 lib
lrwxrwxrwx   1 root root       11 2006-03-30 00:50 linuxrc -> bin/busybox
drwxr-xr-x   2 root root     4096 2006-03-30 00:50 sbin

制作根文件系统
--------------
1,基本目录结构
#mkdir /mnt/rootfs
#cd /mnt/rootfs
#mkdir etc usr var tmp proc home root dev
#chmod 1777 tmp
进入usr
#mkdir bin sbin
进入var
#mkdir lib lock log run tmp
#chmod 1777 tmp
进入proc
#mkdir self self/fd
#mkdir boot mnt opt (可选)
进入dev
#mkdir pts

其中etc,proc和dev是一定要建的,bin和sbin不用建,因为busybox中已经有了。
其他的可以象征性的建几个就可以了。

拷贝busybox
#cp -a 你的目录/_install/* /mnt/rootfs
*/
2,建立设备文件名

#cd /mnt/rootfs/dev
你可以用mknod手工建立,也可以直接从原系统的/dev目录下拷贝过来。

手工建立的方法:
#ls -l /dev/console
crw------- 1 root root 5, 1 11月 30 09:02 /dev/console
这样就查看到了console设备的主设备号是5,辅设备号是1,是一个标记为C的字符设备。
于是,我们可以用mknod建立一个同样的设备文件:

#mknod console c 5 1

但是手工方法建立太麻烦了,通常直接从/dev下把需要的设备文件拷贝过来。
这些设备文件是特殊文件,在拷贝时一定要加上-R参数才能拷贝。

#cp -R /dev/console ./
#cp -R /dev/null ./
#cp -R /dev/zero ./
...

另外可以代替：
#mknod -m 600 mem c 1 1
#mknod -m 644 random c 1 8
挂载eldk下面的/usr/local/eldk/arm/images的ramdisk_image.gz
#gunzip -v ramdisk_image.gz
#mkdir -p /mnt/tmp
#mount -o loop ramdisk_image /mnt/tmp
拷贝/mnt/tmp/dev到/mnt/rootfs/dev
#cp -R /mnt/tmp/dev/* /mnt/rootfs/dev
*/
进入/dev
#cp -R cdrom fd0 hda14 hda4 hdb11 hdb19 hdc hdc16 hdc6 hdd13 hdd3 loop2 ram2 /mnt/rootfs/dev
#cp -R console fd0H1440 hda15 hda5 hdb12 hdb2 hdc1 hdc17 hdc7 hdd14 hdd4 loop3 tty0 /mnt/rootfs/dev
#cp -R fb hda hda16 hda6 hdb13 hdb3 hdc10 hdc18 hdc8 hdd15 hdd5 loop4 tty1 /mnt/rootfs/dev
#cp -R fb0 hda1 hda17 hda7 hdb14 hdb4 hdc11 hdc19 hdd hdd16 hdd6 loop5 tty2 /mnt/rootfs/dev
#cp -R fb1 hda10 hda18 hda8 hdb15 hdb5 hdc12 hdc2 hdd1 hdd17 hdd7 null tty3 /mnt/rootfs/dev
#cp -R fb2 hda11 hda19 hdb hdb16 hdb6 hdc13 hdc3 hdd10 hdd18 hdd8 ram tty4 /mnt/rootfs/dev
#cp -R fb3 hda12 hda2 hdb1 hdb17 hdb7 hdc14 hdc4 hdd11 hdd19 initctl ram0 tty5 /mnt/rootfs/dev
#cp -R fb4 hda13 hda3 hdb10 hdb18 hdb8 hdc15 hdc5 hdd12 hdd2 loop1 ram1 zero /mnt/rootfs/dev
#cp -R usbdev* /mnt/rootfs/dev
#mkdir bus
#cp -R bus/* /mnt/rootfs/dev/bus/
*/
如果“没有找到文件”是可以忽略的
#cp -R /dev/pts/0 /mnt/rootfs/dev/pts
#ln -s ../proc/self/fd fd
#ln -s fd/0 stdin
#ln -s fd/1 stdout
#ln -s fd/2 stderr
进入proc/self/fd/
#ln -s ../../../dev/pts/0 0
#ln -s ../../../dev/pts/0 1
#ln -s ../../../dev/pts/0 2

以下是我认为可以加入的设备名:
cdrom fd0 hda14 hda4 hdb11 hdb19 hdc hdc16 hdc6 hdd13 hdd3 loop2 ram2
console fd0H1440 hda15 hda5 hdb12 hdb2 hdc1 hdc17 hdc7 hdd14 hdd4 loop3 tty0
fb hda hda16 hda6 hdb13 hdb3 hdc10 hdc18 hdc8 hdd15 hdd5 loop4 tty1
fb0 hda1 hda17 hda7 hdb14 hdb4 hdc11 hdc19 hdd hdd16 hdd6 loop5 tty2
fb1 hda10 hda18 hda8 hdb15 hdb5 hdc12 hdc2 hdd1 hdd17 hdd7 null tty3
fb2 hda11 hda19 hdb hdb16 hdb6 hdc13 hdc3 hdd10 hdd18 hdd8 ram tty4
fb3 hda12 hda2 hdb1 hdb17 hdb7 hdc14 hdc4 hdd11 hdd19 initctl ram0 tty5
fb4 hda13 hda3 hdb10 hdb18 hdb8 hdc15 hdc5 hdd12 hdd2 loop1 ram1 zero

其中,fd0,hda,ram0,ttyS0,tty1,null,zero,loop1,fb0,fb等是必备的.
其它的hda,hda1,hdb等可以根据实际需要决定.但是上表中的选择是比较合理的,即能满足大部分的需要,有没有不用的设备浪费空间。注意,千万不要把/dev下的设备全拷贝过来,那将产生大约420K的/dev目录,这样来说太大了。

3,建立etc目录下的配置文件

busybox.conf group inittab motd passwd resolv.conf
fstab init.d issue mtab profile shadow modules.conf

执行：
touch busybox.conf group inittab motd passwd resolv.conf
touch fstab issue mtab profile shadow modules.conf

其中init.d是一个目录,从busybox源代码目录下拷贝过来。

#cp -R 你的目录/examples/bootflopyp/etc/init.d /mnt/rootfs/etc/

busybox.conf是一个空文件
其他文件的内容如下:

fstab：
/dev/fd0 /  ext2  defaults 0 0
none  /proc  proc  defaults 0 0
none  /dev/pts devpts  mode=0622 0 0

group：
root:x:0:root
bin:x:1:root,bin,daemon
daemon:x:2:root,bin,daemon
sys:x:3:root,bin
tty:x:5:
disk:x:6:root
lp:x:7:daemon
mem:x:8:
kmem:x:9:
ftp:x:50:
nobody:x:99:
users:x:100:

inittab：
::sysinit:/etc/init.d/rcS
::respawn:/sbin/getty 115200 ttyS0
::respawn:/bin/sh
::askfirst:/bin/sh
# Stuff to do when restarting the init process
::restart:/sbin/init
# Stuff to do before rebooting
::ctrlaltdel:/sbin/reboot
::shutdown:/bin/umount -a -r
::shutdown:/sbin/swapoff -a

issue：
Lianic Arm Linux release 0.1(2006-04-05)

motd是一个空文件

mtab是一个空文件

passwd：
root:x:0:0:root:/:/bin/ash
bin:x:1:1:bin:/bin:
daemon:x:2:2:daemon:/sbin:
halt:x:7:0:halt:/sbin:/sbin/halt
ftp:x:14:50:FTP User:/
nobody:*:99:99:Nobody:/:

profile：
# /etc/profile: system-wide .profile file for the Bourne shells
export PS1="[u@h w]$"
echo "Done"
alias ll='ls -l'11 ll
alias du='du -h'
alias df='df -h'
alias rm='rm -i'
echo
# Set path
PATH=/bin:/sbin:/usr/bin:/usr/sbin
export PATH

resolv.conf：dns域名解析
nameserver 127.0.0.1
search localhost