Linux内核Makefiles教程(一)

Linux内核Makefiles

本教程描述了了Linux内核的Makefile是如何工作的。

1. 概述

Linux内核的Makefile包括五个部分。

Makefile	最上层Makefile
.config	内核配置文件。
arch/$(ARCH)/Makefile	CPU架构相关Makefile
scripts/Makefile.*	对于所有Kbuild Makefile的公共方法。.
kbuild Makefiles	有将近500个kbuild Makefiles。

最上层Makefile读取.config文件。.config文件是由内核配置过程生成的。

最上级的Makefile负责生成linux的内核映象文件vmlinux和其它所有的模块。最上级Makefile递归地进入内核代码树的各级子目录分别执行子目录下的Makefile。究竟要进入哪些子目录是由内核配置阶段决定的，即配置在.cncfig文件中。最上级Makefile提定了一个路径为arch/$(ARCH)/Makefile的子目录Makefile。这个Makefile中定义了与处理器架构紧密相关的信息。

每一个子目录下面都有一个kbuild Makefile，这里都定义了一些makefile命令和变量可以被更下级的Makefile继承。Kbuild Makefile使用来自.config配置的信息生成各种文件列表用来构建内建的或者模块化的目标文件。Scripts/Makefile.*包括了很多被其它Makefile使用定义和规则。

2. 谁使用内核Makefile

内核Makefile的使用者可以大致分为四种。

用户(Userse)

这类使用者仅仅敲入一些命令，如“make menuconfig”或者“make”。他们很少会阅读甚修改内核Makefile和源代码文件。

一般开发者（Normal Developers）

一般开发者一般编写一些设备驱动程序，文件系统，网络协议。他们需要维护他们编写的代码涉及的子系统的kbuild Makefiles。为了工作地更有效率，他们甚至还需要对整个内核的Makefile有全局的把握，包括对kbuild的公共接口的详尽了解。

处理器架构开发者(Arch Developers)

这部分开发者关心与某个处理器架构紧密相关的代码部分，比如PC上最广泛使用的x86，以及IA64，还有ARM,Sparc,PowerPC,Alpha,s390,MIPS。Linux支持几百种处理器架构。从内核2.6.24开始，i386和x86_64合并为x86。

KBuild的开发者(KBuild Developers)

KBuild的开发者就是维护内核构建系统的开发者，他们需要知道内核Makefile的各个方面。

——

本篇教程主要面向第二类开发者和第三类开发者。即一般开发者和处理器体系架构开发者。

3. kbuild文件

大多数内核Makefile文件是kbuild Makefile文件，它们使用不同于一般make文件的kbuild语法。下面会介绍kbuild makefile的语法。Kbuild文件一般被命名为Mafile，但是也可以使用Kbuild名字。如果已经存在一个Makefile文件了，那么就只好用Kbuild名字了。

3.1节 "目标定义"是一个快速简介，更详细的介绍会在下面的章节陆续介绍并有真实的例子。

3.1. 目标定义(Goal Definitions)

目标定义是kbuild Makefile的最重要的部分。它们定义了哪些文件会被构建，并指定一些特殊的选项组合以及将递归进入到哪些子目录。

最最简单的makefile只有一行代码，如：

obj-y += foo.o

这行代码告诉kbuild系统当前目录下有一个目标要构建，它的名字是foo.o。foo.o将从foo.c或者foo.S生成。

如果foo.o需要被构建成一个内核模块，那么应该使用obj-m。因此一般使用下面的模式：

obj-$(CONFIG_FOO) += foo.o

$(CONFIG_FOO)是一个makefile变量，在makefile执行时被替换为y（如果内建到内核）或者m（如果构建成模块）。如果CONFIG_FOO既不是y也不是m，那个这一行代码会被忽略，指定的文件不会被编译也不会被链接。

3.2 内建的对象目标(object goals) obj-y

Kbuild Makefile通过obj-y列表为linux内核映象vmlinux指定目标文件(.o)。究竟是哪些目标文件则取决于内核配置。Kbuild系统会编译所有obj-y列表中的文件。然后Kbuild系统会调用$(LD) -r把所有的这系文件合并到一个built-in.o文件。跟住呢，built-in.o被最上级Makefile链接到linux内核映象文件vmlinux。

在obj-y列表中指定的文件顺序是很重要的。列表中的重复项也是被充许的。首先出现的会被首先链接到built-in.o，后面的重复项会被忽略。

链接的顺序当然也是有重要意义的。因为一些函数调用，如module_init()，_initcall会在系统启动阶段按照他们被链接的先后顺序被调用。所以改变链接的顺序当然会造成意义重大的影响。比如：会改变SCSI控制器被内核发现的先后顺序，因此磁盘的编号则会改变。

#drivers/isdn/i4l/Makefile

# Makefile for the kernel ISDN subsystem and device drivers.

# Each configuration option enables a list of files.

obj-$(CONFIG_ISDN) += isdn.o

obj-$(CONFIG_ISDN_PPP_BSDCOMP) += isdn_bsdcomp.o

(第一篇完) 第二篇

三分钟Qt Quick入门

Qt Quick是一种设计用户界面的新方法。

在介绍Qt Quick之前，让我们先看一下现念的用户界面UI是什么样的。在桌面操作系统下，标准的按钮，文本框，窗体仍然能满足要求。但是这些千篇一律的灰色单调的控件渐渐让用户感到厌倦了。用户们更想看到平滑观感的，光泽的，动态的的用户界面。Qt Quick就是为了实现这些的目标。

Qt Quick包括两个部分。第一部分是QtDeclarative模块。这个模块负责把Qt Quick集成到Qt应用程序中。第二部分是一种界面描述语言：QML。使用QtDeclarative使得开发者能够在C++和QML之间共享数据对象，也可以把C++类插入到QML之中，等等。QML是个全新的语言，专门为设计用户界面设计，在其它的开发中也有用武之地。

迫不及待了吧。让我们看一个简单的例子：

import Qt 4.6

Rectangle {
width: 200
height: 200

Text {
text: "hello! ykyi.net"
font.pointSize: 10
font.bold: true

anchors.centerIn: parent
}
}

读完这断代码，再尝试在Qt Creator中运行它。不用我多费口舌，你就恍然大悟了。每一个以大写字母开头的单词定义了一个新的对象。最外面的矩形则是主窗体，可以给它设置属性。比如anchors属性把Text限定在窗体的中央。这样，即使窗体放大了，文本仍然显示在窗体正中央。

前文，我有说过平滑观感的，光泽的，动态的的用户界面。那么Qt Quick怎么做到呢？简单！看看下面的代码，编辑Text的属性，设置rotation:NumberAnimation。不可思议的事情就发生了！

rotation: NumberAnimation {
to: 360;
duration: 1500;
running: true;
repeat: true;
}

现在，指定的文本疯狂的转动起来。我们已经看到在Qt Quick中开发有物资的界面是多么简单。我们所展示的只是Qt Quick特效的凤毛一角，最终能创造出什么样的奇幻效果只受限于你的想象力。

Barebox介绍

从裸机上电开始启动计算机的过程听起来是相当复杂的。在PC的世界里，BIOS统治这个领域已经几十年了。不过，哲学上讲任何世界都是从出生，到繁荣，再后到死亡的过程。BIOS的寿命也即将迎来终结。BIOS的掘墓者即是EFI。对于MAC用户来说，EFI的使用已经有好长一段时间了。而在嵌入式Linux的世界里，u-boot则在长时间里扮演着老大哥的角色。

U-boot，或者来自DENX的das U-boot提供了非常丰富的功能。如：网络，脚本，支持FLASH(这里的flash是存储方面的flash，而不是adobe的那个flash)。一般的嵌入式系统工程序师需要的工具，都提供好了。

还是那句话，对于万事万物，都是生生死死的过程啊。u-boot的功能越来越强大。催生了新的事物的诞生。它的名字就是：Barebox。

Barebox最开始被称之为：u-boot-v2，它是一个像u-boot一样野心勃勃的bootloader。不过Barebox更有Linux的味道一些。它的发展抛弃了u-boot而越来越像Linux。它有文件系统，有基本的shell，甚至还有与Linux近似的驱动模块。

Barebox的另一个创新即是，bootloader可以被构建成一个用户空间的应用程序。这样的好处是显而易近的，你可以更方便的开方和调试Barebox。

说了这么多，看看Barebox是个什么样子呢？

uboot:/

uboot:/ ls
. .. dev env

和Linux一样，dev目录夹下面放了系统的设备文件。比如，mem设备文件描述了计算机的内存。

再回到u-boot，它有一个特殊的命令：md。md命令可以查看内存的内容。对于Barebox，提供了同样的工具。不过这个工具是以一种POSIX的方式实现的：打开/dev/mem设备，lseek移动文件指针，read读出文件内容。这样的实现方式不仅仅提升了代码结构，它还使得md命令可以不需修改就应用到其它设备上，比如flash存诸器。

如果你想测试一下Barebox到底如何。你可以有两种方法。

第一：你可以下载Barebox的沙盒功能即把它构建成一个Linux的用户空间的应用。来自Barebox官方的解释是：

Sandbox:
If you develop features for Barebox, you can use the 'sandbox' target which compiles Barebox as a POSIX application in the Linux userspace: it can be started like a normal command and even has network access (tun/tap). Files from the local filesytem can be used to simulate devices. 如果你要为Barebox开发功能，你可以使用'沙盒'。这种方式把Barebox构建成一个Linux的用户空间程序。它像一般的命令一样，而且还有网络功能。来自文件系统的文件可以被用来模拟设备。

第二：不说你也知道，把Barebox安装到真真正正的硬件上吧！对于我，我就尝试过在PC机的一块旧式的主板上安装Barebox。

最后，Barebox的官方网站是： http://barebox.org/

Linux如何设置IPv6地址

IPv6最终全面取待IPv6是不可逆的潮流。本文则讲一下在Linux下如何配置IPv6地址。当然本文假设你使用静态IP（不必是公共IPv6地址或公共IPv4地址，可以是私有IPv4地址）。本文不适用使用DHCP获取地址的情况。

首先，你要确保你使用的Linux的内核已经支持IPv6。当前比较新的Linux都已经内建IPv6了。

用root用户登录，运行：

# lsmod | grep ipv6

看看系统有没有已经加载了IPv6模块。如果没有，尝试用以下命令加载：

# /sbin/modprobe ipv6

第二，你需要有你的静态IP地址。

IPv4地址如何转成IPv6地址呢？如果你的IP是一个IPv4地址，那么可以换算得到IPv6的地址形式。比较简单的作法可以去到 http://grox.net/utils/ipv6.php。在左边的下拉列表中选择: IPv4 to 6to4 Address，在右边的编辑框中填上你的IPv4地址。点击: Calculate 则得到了你的IPv4地址的IPv6转化格式。

配置IPv6地址

一般的Linux发行版用 /etc/network/interfaces 文件配置网卡。如果没有这个文件，那么请注意 /etc/network 目录下其它文件或者目录。

假如要配置的Linux的静态IPv4地址是 192.168.1.10，这个IPv4地址转换成对应的IPv6地址则是 2002:c0a8:10a:: 。再提醒一下，上文提到过如何把IPv4地址转成IPv6地址。

网关的IPv4地址是 192.168.1.1，这个IPv4地址转成对应的IPv6的地址是:2002:c0a8:0101:: 。

那么 /etc/network/interfaces 文件应该配置成如下：

#IPV6 static configuration(我是注释)
iface eth0 inet6 static
pre-up modprobe ipv6
address 2002:c0a8:10a::
netmask 64
gateway 2002:c0a8:0101::

注意 "pre-up" 命令。这一行保证系统在启动的时候加载支持ipv6的模块。
最后重新启发动网络，如下：

# /etc/init.d/networking restart

你现在可以使用你的IPv6地址了。

测试IPv6地址：

检测路由：

# ip -6 route show

如果IPv6工作正常的话，应该会有如下的提示。

2002:c0a8:0100/64 dev eth0 proto kernel scope link src 2002:c0a8:10a

你也可以用IPv6版本的ping工具测试。首先想到的最好的IPv6地址当然是google的，使用如下命令：

ping6 ipv6.google.com

如果ipv6不工作，你会得到错误信息：Network is unreachable

If IPv6 is working you will see the standard ping results in your terminal window.

如果IPv6工作正常，那么你可以看到标准的ping命令的输出。

后记：IPv6是下一代互联网的工业标准。如果你是一位IP从业人员，即时跟进IPv6技术是必须的。如果只是普通的民众，则可以不必理会，大多数情况下你感觉不到IPv6和IPv4的区别，你就平滑过渡到IPv6的时代了。

X86平台的中断和异常

英特尔的官方文档如下定义x86平台下的中断和异常：

中断：

可屏弊中断(Maskable Interrupts)

所有由I/O设备发出的IRQ(Interupt Requests)都是可屏弊中断。可屏弊中断可以有两个状态：屏弊和未屏弊。屏弊状态的中断会被中断控制硬件忽略。

不可屏弊中断(Nonmaskable Interrupts)

只有一些关键的事件（如硬件失败）会发出不可屏弊中断。不可屏弊中断总是可以被CPU识别到。

异常：

处理器可侦测异常(Processor-detected Exceptions)

CPU执行指令时侦测到不正常的状态(anomalous condition)时产生这个异常。这种异常又根据存在内核栈上的EIP寄存器的值被划分为三组。

错误(Faults)

发生错误时，一般情况下可以被纠正。纠正以后，程序继续运行，不会损失连续性。保存下的EIP寄存器的值就是产生这个错误的指令，当异常处理句柄（exception handler）结束后，程序从这条指令继续运行。

陷入(Traps)

当被中止的指令无需重新执行时就产生陷入，这点与错误(Faults)不同。陷入主要被用来实现调试器。

中止(Aborts)

严重出错。控制硬件出现故障，此时不可能把造成异常的指令精确地址存入EIP寄存器。Aborts被用来报告严重的出错，比如硬件出错或者无效的，不一致的系统表结构。由控制硬件单元发出的中断信号被用来把控制权转交给中止异常句柄(Abort Exception Handler)。句柄通常只有强制结束造成Abort的程序。

可编程异常(Programmed Exceptions)

这是由程序员发出的。程序员可以用int 或者int 3指令发出可编程异常。Into(检查溢出)bound(检查数组越界)指令也可以用来发出可编程异常。可编程异常常常被称之为软中断(software interrupts)。这种异常通常用来实现系统调用，还被用来在调试器中报告事件。(into和bound指令在IA64体系中已经被废弃了，见另一篇博文：C语言和它的安全性)

It’s a mistake to include Xen in a Linux distro

As the title show, it's a mistake to include Xen in a linux distro. Why?

Somebody would argue that Xen is a very useful technology. Xen does the virtualization work very well and many projects are using Xen which prove Xen is so great.

I'm not mean Xen is not good. However, just because Xen is a hypervisor that is based on another microkernel that is not Linux kernel itself. Linux distros that ship Xen today actually are running an entirely different Operating System kernel that most users even don't notice that. Xen should be a separate, purpose-built kernel, so it should never be a part of the Linux kernel. Isn't it strange that you think you are running a linux OS, but this 'linux' has a kernel that is not linux, which is another kernel. You take away the Linux kernel, how could you say the OS is Linux.

Just before the born of the Linux native virtualization KVM, the distros shipped Xen because there exist no other choices. Many Linux developers at that time know little about virtualization. Xen seemed a pretty easy and pretty good choise. So the Linux community made the hasty decision to ship Xen instend of investing in makeing Linux's own hypervisor. But now KVM has come for more than five years(since kernel 2.6.20 in Feb, 2007. KVM actually has a longer history. It was out there before being merged into mainline kernel code.) and KVM has proven itself to be completent to replace Xen. The most important thing is that KVM as a part of the linux kernel leverages the features of kernel like memory management, process scheduling and so on, making the kernel a perfect hypervisor. So, there is no reasons to ship Xen in Linux distros any more.

traceroute failed.Specify protocal traceroute used manually to fix it.

Today, I ran the traceroute program on a machine running FreeBSD. It failed once and again.

Traceroute complained:

traceroute: sendto: Permission denied.

So I tried to ping. Ping failed, too. I then checked out the configuration of the firewall, which actually denied the pass through of ICMP packet. So I set it to allow ICMP pacakges to pass through the firewall. Ping worked as I expected. But traceroute still failed.

I was very confused, I tried to run the tcpdump to find out why. Tcpdump showed that traceroute was sending UDP packet. Oh, my gosh. I had always thought traceroute was implemented on ICMP. After I read the tcpdump manpage. I found traceroute default on using udp protocal, but user can switch to use icmp by indicating the -M icmp or -I(The capitalized i). Alternatively, you can also command traceroute to use raw packet of specified protocol for tracerouting by specifying -P(beware P is capitalized). When you use raw packet, the default protocol is 253 (rfc3692). So, I ran traceroute using the command as: traceroute -P ICMP www.the_host.com, everything worked fine.

如何正确地提交内核补丁包

原文：https://lwn.net/Articles/500443/

翻译：ykyi.net

Greg Kroah-Hartman(又Greg KH)在执行一个了不起的作务：减少内核开发者，尤其是维护者的暴躁情绪。他在日本横滨举行的全球Linux大会上的讲演呼吁公众理解内核维护者的工作，内核贡献者的什么样的行为会导致内核维护者变得暴戾。但是，如果内核贡献者们能够遵守一些约束，他代表他自己做了许多承诺。

Greg Kroah Hartman把Linux内核称之为"有史以来最宏大的软件开发项目"，而且它的开发速度也是“亘古未有”。从3.0到3.4，有373个公司的2833位开发者参于了Linux内核的开发。这一年，(2011年的5月到，2012年的5月)，Linux内核在每个小时会有5.79处变动。而且这个开发速度仍然要加速，如果你看看3.4的开发过程，每小时共有7.21处变动。这里所说的变动仅仅指能够被合并到主干的补丁包，而那些被拒绝的补丁包没有被统计进来。

补丁包修改了哪些文件，内核开发者就把补丁包发给负责这些文件的维护者。所以的内核维护者，现在大概有700人。他们把改变应用到130个子系统的维护者那里。再从子系统的维护者到Linus的Linux内核代码分支。最后并必Linux内核的主干。如果提交的补丁包一路通过的话。

因此，来看看为什么一些补丁包不会被接受呢？Greg Kroah Hartman以刚过去的两个星期收到的补丁包为例，这两个星期刚好处于3.5版本的Merge Window时间。Merge Window是一个他确不应该接收到许多补丁包的时间段。他应该在Merge Window开始前收到所以有可能会在Merge Window其间被发往Linux Torvalds的补丁包。不过，他说他在这两个星期的时间里收到487个补丁包。其中的大多数都有很多问题，有些补丁包来自那些本应该对内核有更好理解的内核开发者们。

坏的补丁包

Greg KH举例说明了一些他收到的坏的补丁包。其中一个补丁包被命名为：patch 48/48(一个有48个补丁集的最后一个)，但是其它的47个都没有。他还收到一堆补丁但没有写清楚先后顺序。如此，他要么猜测一个顺序，这毫无疑问会失败。另一个替代方案就是安全不管这个补丁了。另外还收到过有10个补丁的补丁集，但是2号补丁确丢失了。

另外有一个通过邮件发送来的补丁包被声明“机密”。Greg KH说他经常收到此类方式的补丁。对于此类补丁，你无能为力。因为Linux是在开放的生态中开发的，你不能够给邮件列表发送一个机密邮件偷偷就合并一个补丁。很明显，这种方式发来的补丁是因为在处理邮件阶段的模板造成的，但是'机密'必须被去掉。

还有不良排版的补丁包。比如所有的Tab符都被转成了空格，Microsoft Exchange常常这么做。如果对于你，开发环境是个问题的话，那可以像IBM，Microsoft或者还有其它公司那样，在角落里再放一台Linux机器给开发者用来发送邮件。有时候diff的输出的行前空格都被剥去了，或者diff的输出并不是unified格式(见另一篇博文，讲述如何用diff生成linux内核补丁包)。虽然久经考验的Linux开发者们可以熟练的编辑原始diff输出格式，但是diff的原始输出本身是件很令人恐怖的事情，他们本不应该被如此对待编辑它们。

有些补丁包是在错误的目录下被创建的，比如在一个驱动器目录下。有个补丁包在/usr/src/linux-2.6.32目录下被创建，但是这个补丁包里面有好些错误，包括源代码树的年龄，而且它隐含假设它是在root上构建。在root上构建是相当之危险，如果linux的构建过程中出现一个bug，就有可以把整个文件系统都删除。没有一个内核核心开发者留意到了这个情况，因为他们没有使用root。有建议说把这种bug留下来当成一种威慑力（原作者开玩笑），自然不会被采纳，不过那么极端的危险情况是真的有可能发生啊。

还有离谱的，有些补丁包是针对一个本来与这个补丁包毫无关系的代码树。Greg KH说他曾经收到一个补丁包针对SCSI代码树，实在想不通这个与SCSI毫无关系的补丁关怎么会针对SCSI代码树创建。

然后还有代码风格的问题。有些补丁包没有使用Linux内核的代码风格。提交补丁包的开发者也知晓这个问题，但是他们似乎在说“我不管，让我的代码通过吧！”Greg KH说，现有一些工具可以帮助定位到有这些问题的代码并修复它们。所以，没有任何借口发送不符合代码风格的补丁包。

Greg KH还着重说了编译不能通过的问题。他说，有些内核内核贡献者把不能通过编译的补丁包也发过来。或者有些补丁包集3/6失败了，在6/6修复了。我甚于收到过补丁包在5/8失败，但是作者附带了一个说明说作者在未来某个时候会发来改正方案。另外还有补丁包很明显没有正确的内核文档部分，因为在构建文档的时候会失败，很明显补丁包的创建者根本就没有运行过内核文档抽取工具。(不想译了，太多了…呜~~累死了.)

One of the patches he got "had nothing to do with me". It was an x86 core kernel patch, which is not an area of the kernel he has ever dealt with. But the patch was sent only to him. "I get odd patches" a lot, he said.

The last patch he mentioned was 450K in size, with 4500 lines added. Somebody suggested that it be broken up, but in the meantime several maintainers actually reviewed it, so the submitter didn't really learn from that mistake.

All of this occurred during a "calm two weeks", he said. These are examples of what maintainers deal with on a weekly basis and explains why they can be grumpy. That said, he did note that this is the "best job I've ever had", but that's not to say it couldn't be improved.

If someone sends him a patch and he accepts it, that means he may have to maintain it and fix bugs in it down the road. So it's in his self interest to ignore the patch, which is an interesting dynamic, he said. The way around that is to "give me no excuse to reject your patch"; it is as simple as that, really.

Rules

Kroah-Hartman then laid out the rules that contributors need to follow in order to avoid the kinds of problems he described. Use checkpatch.pl, he said, because he will run it on your patch and it is a waste of his time to have to forward the results back when it fails. Send the patch to the right people and there is even a script available (get_maintainer.pl) to list the proper people and mailing lists where a patch should be sent.

Send the patch with a proper subject that is "short, sweet, and descriptive" because it is going to be in the kernel changelog. It should not be something like "fix bugs in driver 1/10". In addition, the changelog comment should clearly say what the patch does, but also why it is needed.

Make small changes in patches. You don't replace the scheduler in one patch, he said, you do it over five years. Small patches make it easier for reviewers and easier for maintainers to accept. In a ten-patch series, he might accept the first three, which means that the submitter just needs to continue working on the last seven. The best thing to do is to make the patch "obviously correct", which makes it easy for a maintainer to accept it.

Echoing the problems he listed earlier, he said that patches should say what tree they are based on. In addition, the order of the patches is important, as is not breaking the build. The latter "seems like it would be obvious" but he has seen too many patches that fail that test. To the extent that you can, make sure that the patch works. It is fine to submit patches for hardware that you don't have access to, but you should test on any hardware that you do have.

Review comments should not be ignored, he said. It is simply common courtesy if he takes time to review the code that those comments should be acted upon or responded to. It's fine to disagree with review comments, but submitters need to say why they disagree. If a patch gets resent, it should be accompanied with a reason for doing so. When reviewer's comments are ignored, they are unlikely to review code the next time.

Maintainer's role

When you follow those rules there are certain things you can expect from him, Kroah-Hartman said, and that you should expect from the other maintainers as well. That statement may make other maintainers mad, he joked, but it is reasonable to expect certain things. For his part, he will review patches within one or two weeks. Other maintainers do an even better job than that, he said, specifically pointing to David Miller as one who often reviews code within 48 hours of its submission. If you don't get a response to a patch within a week, it is fine to ask him what the status is.

He can't promise that he will always give constructive criticism, but he will always give "semi-constructive criticism". Sometimes he is tired or grumpy, so he can't quite get to the full "constructive" level. He will also keep submitters informed of the status of their patch. He has scripts that will help him do so, and let the submitter know when the patch gets merged into his tree or accepted into the mainline. That is unlike some other maintainers, he said, where he has submitted patches that just drop into a "big black hole" before eventually popping up in the mainline three months later.

He ended by putting up a quote from Torvalds ("Publicly making fun of people is half the fun of open source programming. …") that was made as a comment on one of Kroah-Hartman's Google+ postings. The post was a rant about a driver that had been submitted, which even contained comments suggesting that it should not be submitted upstream. He felt bad about publicly posting that at first, but Torvalds's comment made him rethink that.

Because kernel development is done in the open, we are taking "personal pride in the work we do". As the code comment indicated, the driver developer didn't think it should be submitted because they realized the code was not in the proper shape to do so. It is that pride in the work that "makes Linux the best engineering project ever", he said. Sometimes public mocking is part of the process and can actually help instill that pride more widely.

Linux内核维护者的职责

原文: http://www.linuxfoundation.org/news-media/blogs/browse/2012/06/role-linux-kernel-maintainer

翻译: ykyi.net

几个星期前在日本举行的Linux大会(LinuxCon)上，我做了一个演讲，题目是"Linux内核维护者，他们在做什么，如何能够帮到他们"。

这个演讲的视频可以通过这个链接看到。如果你想要幻灯片，和我的讲演稿，可以在这个地址获得。

如果你之前觉得为什么一个开源工程的维护者对发给他/她的东西总是如此古怪乖戾，那我强烈推荐你去看看我为这个演讲写的笔记，或者幻灯片，里面包含了所有的笔记。

另外，如果你想要知道如何才能令你的内核补丁包得到通过，请先看看上文提到的幻灯片，我不想过多重复了。

嗯，有一个例外！

首先，看起来我的这个演讲引发了一连串热烈的讨论。最最开始是因为Jake Edge在lwn.net上一篇精彩的总结(这篇文章我有翻译前半部分，点击这里)，引来了大量评论各有大量围观群众。这些人中的绝大部分应该没有看过上面提到的幻灯片，也应该看到我的演讲的视频，无论如何还是激起了大家的兴趣。普罗大众总是会因为某些人在大吵的时候兴奋地在一旁围观。

接着，Jon Corbet撰文加入了争论。他做了一个非常非常好的总结：开源工程的维护者们总是被海量的低质量提交沦陷，总是要日复一日地不停地回复已经被回答过好多次的同样问题。人们看起来从不去阅读文档，而通常在文档里就能找到答案。再一次，强烈建议你看看上文提到的幻灯片或者笔记或者视频。刚才提到的两篇文章也值得一读，包括下面的精彩评论。

(什么，你还没有订阅过 lwn.net，为什么不订阅呢？真是为你感到羞愧啊！现在还不快去订阅？) 译者注：订阅lwn.net是要支付付用的。原作者在文章中给lwn.net做广告呵呵。

后来, Linux内核峰会的召集期限已过，收到的很多提议都是关于内核维护者的。他们的工作量，如何解决已经出现的棘手问题。如果你有兴趣的话，可以在这里了解到到底我们在为什么抓狂。

对于我演讲里所讲述过的内容，在这里我还想重复的是：身为一个内核子系统的维护者，对于那些给我发送关于我负责的内核部分的内核补丁包的开发者，我如下承诺：

我会在一到两个星期内复审你的补丁包(参见下文)
我会对你的补丁包提出准建设性的批判意见。
如果你提交的补丁包被拒绝的话，我会给你被拒的理由。如果补丁包被接收，我会告诉你补丁包会被合并到哪个分支，你可以从哪里看到它以及什么时候你可以看到它最终被合并到linus的分支中。

就这样。对于提交者，我希望看到格式良好，文档丰富，可以整洁地应用到代码树的补丁包，而且做了真正有用的事情。这样的话，你我都会很开心，是吗？

对意下一到两周的回复时间：

当然了，如果我生病了，或者我正在这个星球上某个地方旅行。我的回复就会适当延迟。你绝对可以随时发邮件给我询问你的patch的状态。我很乐意回复这些邮件。我宁可一一处理好所有这些询问邮件，而不是让等待了几周的开发者发疯。

另外，要注意一下合并窗口(Merge Window)的问题。在整个Merge Window阶段，我不能接受任何在我的分支Release上还没有修正所有已知bug的补丁包。所以这意味着，通常在Linus的Release前一周开始，一共三周的时间内，我不会处理你提交的补丁包。在这段时间内，上百份补丁包会堆积起来，所以请给我一些时间让我从补丁海里面脱身出来。一般到-rc3的时候，我就赶上了，但如果没有呢，人可以写邮件给我咨询。

使用Cscope阅读大型工程Linux内核的源代码教程

Cscope是一个非常有用的工具，可以用来方便地阅读很大型工程的源代码。较之使用传统的Unix工具grep，使用Cscope可以省下你一大笔时间，大大提高阅读代码的效率。

通过本教程，我会教给你如何使用Cscope阅读Linux内核的源代码。毫无疑问，你可以举一反三，用同样的方法阅读其它的大型工程的源代码，不仅仅是C语言写的工程，也可以是Java或者C++或者C#开发的工程。

STEP 1 获得源代码：

去到Linux内核的网站http://www.kernel.org下载随便一个版本的Linux内核源代码压缩包。然后解压缩，把源代码释放到某个目录。本文假设你把源代码释放到 /home/code/linux-2.6.26。

STEP 2 选择一个目录存放Cscope所需要的数据库文件。

本文假设选择用/home/cscope目录存放cscope的数据库文件和其它一些相关文件。

STEP 3 生成文件 cscope.files

在最简单的情况下，工程目录下的所有源代码都是我要关心的，于是可以跳过下面所述，简单地在工程的根目录下运行'cscope -R'命令，这样Cscope就会在工程目录下所有源代码中处理相关工作。

但是你关心的代码并必工程目录下所有的代码，你还需要排除很多目录下的大量代码该如何做呢？在这种情况下，你需要生成一个文件cscope.files，这个文件包含了所有cscope将要扫描的文件的文件名，每个名字占一行。最好使用绝对路径，这样你就可以在其它目录下，而不是现在创建cscope.files文件的目录下使用这个刚创建的数据库。下面的代码将完成这个任务（假设我要所有的java文件）：

$ cd /

$ find /my/project/dir -name "*.java" > /my/cscope/dir/cscope.files

对于Linux内核来讲，情况还要稍微复杂一点。因为我们还要排除好些文件夹，这些文件夹有存放文档的文件夹，存放脚本的文件夹，与处理器架构相关的汇编代码的目录夹，与处理器架构相关的C代码除了x86（大多数人已经仅仅对x86感兴趣），另外还会排除所有的驱动文件目录夹，因为驱动占了内核很大一部分，但驱动代码通常不是我们要关心的。如果不排除这些目录的话，cscope当然也能工作，但是却给我们增加了麻烦，因为大大增加了重复的定义出现的概率。下面看我怎么做：

$ LNX=/home/linux-2.6.26

$ cd /

$ find $LNX \

-path "$LNX/arch/*" ! -path "$LNX/arch/i386*" -prune -o \

-path "$LNX/include/asm-*" ! -path "$LNX/include/asm-i386*" -prune -o \

-path "$LNX/tmp*" -prune -o \

-path "$LNX/Documentation*" -prune -o \

-path "$LNX/scripts*" -prune -o \

-path "$LNX/drivers*" -prune -o \

-name "*.[chxsS]" -print >/home/jru/cscope/cscope.files

如果对Unix常用工具find熟悉的话，看懂上面的这个复杂命令应该不是问题。但是我想有必要稍微说明一下。

比如 -path “$LNX/include/asm-*” ! -path “$LNX/include/asm-i386*” -prune -o \ 表示排除 $LNX/include/asm-目录下的所有但是又不排该目录下的 asm-i386 目录。

-prune是排除的意思。那 -o 又是什么呢？ -o表示逻辑或，如果逻辑或前面的表达式为真(即文件满足被排除的条件)，根据or表达式的”短路语法“，-o后面的命令就不会再执行。如果文件名不满足-o前面的排除条件就会再应用-o后面的条件。我们可以看来后面用好几个 -o 把好几个排除条件连在一起。如果你不需要排除其它某些文件，就可以把相应的行去掉。题外话，古老的Unix工具链虽然看上去晦涩难懂，但是一但掌握却是可以受益终生。你想想那么多常用的Unix工具自从70年代发明后就一直广泛使用。已经快40年了！仍然在开源世界广泛使用，想想微软的技术，刚开完发布的新闻发布会，马上又宣布将废除使用了。这方面的思想可以参见《unix编程艺术》一书相关部分的阐述。

STEP 4 下面生成cscope的数据库文件。

$ cd /home/cscope #上一步生成的 cscope.files放在这个目录夹下面.

$ cscope -b -q -k

-b 选项告诉cscope仅仅创建数据库文件，不要在之后启动cscope的介面。 -q选项使得生成数据库的时间增加，但是明显降低之后使用数据库文件时的搜索速度。对于大型工程建议使用这个选项，对于小工程则可不必。-k选项使得cscope不会去/usr/include中处理你的源代码中#include的文件。

STEP 5

到此，就可以执行cscope了。如:

$ cscope -d

注意 -d 选项。加上这个选项则cscope不会在启动时重新检查所有有没有文件更新，有更新还会重建数据库，即使没有更新对于大型工程也要花费一些时间。如果有文件更改，你又想反映这个变化，那就不能加上-d选项。如果有新的文件加入，则需要从STEP 3重新开始，或者手动把增加的文件加入 escope.files，每个文件一行！如果你喜欢cscope，那么再参看man page，多多学习吧！

总结，Linux下的很多开发工具和成熟的GUI丰富的商业开发环境比较起来真的非常不方便呀。打字辛苦，转载请注明出处 ykyi.net ！谢谢~