LinuxProc文件系统

刺骨的言语ヽ痛彻心扉 2022-07-11 19:53 146阅读 0赞

# 理解 Proc 文件系统 #

[http://linux.chinaunix.net/doc/2004-10-05/16.shtml][http_linux.chinaunix.net_doc_2004-10-05_16.shtml]

<table style="width: 560px;"> 
 <tbody> 
  <tr> 
   <td align="center">作者：王旭 翻译 2004-10-05 18:25:55 来自：linuxfocus</td> 
  </tr> 
  <tr> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><span> <br><span style="font-size: small;"><em>目录</em>: </span> 
     <ul> 
      <li><a rel="nofollow"><span style="color: #0000ff;">/proc --- 一个虚拟文件系统</span></a> </li> 
      <li><a rel="nofollow"><span style="color: #0000ff;">加载 proc 文件系统</span></a> </li> 
      <li><a rel="nofollow"><span style="color: #0000ff;">察看 /proc 的文件</span></a> </li> 
      <li><a rel="nofollow"><span style="color: #0000ff;">得到有用的系统/内核信息</span></a> </li> 
      <li><a rel="nofollow"><span style="color: #0000ff;">有关运行中的进程的信息</span></a> </li> 
      <li><a rel="nofollow"><span style="color: #0000ff;">通过 /proc 与内核交互</span></a> </li> 
      <li><a rel="nofollow"><span style="color: #0000ff;">结论</span></a> </li> 
      <li><a rel="nofollow"><span style="color: #0000ff;">参考文献</span></a></li> 
     </ul> <br>&nbsp; 
     <table> 
      <tbody> 
       <tr> 
        <td> <p><em>摘要</em>: </p> <p> </p> <p>Linux 内核提供了一种通过 /proc 文件系统，在运行时访问内核内部数据结构、改变内核设置的机制。尽管在各种硬件平台上的 Linux 系统的 /proc 文件系统的基本概念都是相同的，但本文只讨论基于 intel x86 架构的 Linux /proc 文件系统。 </p> <br> <span style="color: #8282e0;"><strong>_________________ _________________ _________________</strong></span><br></td> 
       </tr> 
      </tbody> 
     </table> <a rel="nofollow">&nbsp;</a> <h2>/proc --- 一个虚拟文件系统</h2> <p>/proc 文件系统是一种内核和内核模块用来向进程 (process) 发送信息的机制 (所以叫做 /proc)。这个伪文件系统让你可以和内核内部数据结构进行交互，获取 有关进程的有用信息，在运行中 (on the fly) 改变设置 (通过改变内核参数)。 与其他文件系统不同，/proc 存在于内存之中而不是硬盘上。如果你察看文件 /proc/mounts (和 mount 命令一样列出所有已经加载的文件系统)，你会看到其中 一行是这样的： </p> <br> <pre>grep proc /proc/mounts
/proc /proc proc rw 0 0
</pre> <p>/proc 由内核控制，没有承载 /proc 的设备。因为 /proc 主要存放由内核控制的状态信息，所以大部分这些信息的逻辑位置位于内核控制的内存。对 /proc 进行一次 'ls -l' 可以看到大部分文件都是 0 字节大的；不过察看这些文件的时候，确实可以看到一些信息。这怎么可能？这是因为 /proc 文件系统和其他常规的文件系统一样把自己注册到虚拟文件系统层 (VFS) 了。然而，直到当 VFS 调用它，请求文件、目录的 i-node 的时候，/proc 文件系统才根据内核中的信息建立相应的文件和目录。 </p> <a rel="nofollow">&nbsp;</a> <h2>加载 proc 文件系统</h2> <p>如果系统中还没有加载 proc 文件系统，可以通过如下命令加载 proc 文件系统：</p> <p>mount -t proc proc /proc </p> 上述命令将成功加载你的 proc 文件系统。更多细节请阅读 mount 命令的 man page。 <p>&nbsp;</p> <a rel="nofollow">&nbsp;</a> <h2>察看 /proc 的文件</h2> <p>/proc 的文件可以用于访问有关内核的状态、计算机的属性、正在运行的进程的状态等信息。大部分 /proc 中的文件和目录提供系统物理环境最新的信息。尽管 /proc 中的文件是虚拟的，但它们仍可以使用任何文件编辑器或像'more', 'less'或 'cat'这样的程序来查看。当编辑程序试图打开一个虚拟文件时，这个文件就通过内核中的信息被凭空地 (on the fly) 创建了。这是一些我从我的系统中得到的一些有趣结果： </p> <pre>$ ls -l /proc/cpuinfo
-r--r--r-- 1 root root 0 Dec 25 11:01 /proc/cpuinfo

$ file /proc/cpuinfo
/proc/cpuinfo: empty

$ cat /proc/cpuinfo

processor       : 0
vendor_id       : GenuineIntel
cpu family      : 6
model           : 8
model name      : Pentium III (Coppermine)
stepping        : 6
cpu MHz         : 1000.119
cache size      : 256 KB
fdiv_bug        : no
hlt_bug         : no
sep_bug         : no
f00f_bug        : no
coma_bug        : no
fpu             : yes
fpu_exception   : yes
cpuid level     : 2
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca
cmov pat pse36 mmx fxsr xmm
bogomips        : 1998.85

processor       : 3
vendor_id       : GenuineIntel
cpu family      : 6
model           : 8
model name      : Pentium III (Coppermine)
stepping        : 6
cpu MHz         : 1000.119
cache size      : 256 KB
fdiv_bug        : no
hlt_bug         : no
sep_bug         : no
f00f_bug        : no
coma_bug        : no
fpu             : yes
fpu_exception   : yes
cpuid level     : 2
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca
cmov pat pse36 mmx fxsr xmm
bogomips        : 1992.29
</pre> <br>这是一个从双 CPU 的系统中得到的结果，上述大部分的信息十分清楚地给出了这个系统的有用的硬件信息。有些 /proc 的文件是经过编码的，不同的工具可以被用来解释这些编码过的信息并输出成可读的形式。这样的工具包括：'top', 'ps', 'apm' 等。 <br> <p>&nbsp;</p> <a rel="nofollow">&nbsp;</a> <h2>得到有用的系统/内核信息</h2> <p><br>proc 文件系统可以被用于收集有用的关于系统和运行中的内核的信息。下面是一些重要的文件： </p> 
     <ul> 
      <li>/proc/cpuinfo - CPU 的信息 (型号, 家族, 缓存大小等) </li> 
      <li>/proc/meminfo - 物理内存、交换空间等的信息 </li> 
      <li>/proc/mounts - 已加载的文件系统的列表 </li> 
      <li>/proc/devices - 可用设备的列表 </li> 
      <li>/proc/filesystems - 被支持的文件系统 </li> 
      <li>/proc/modules - 已加载的模块 </li> 
      <li>/proc/version - 内核版本 </li> 
      <li>/proc/cmdline - 系统启动时输入的内核命令行参数 </li> 
     </ul> proc 中的文件远不止上面列出的这么多。想要进一步了解的读者可以对 /proc 的每一个文件都'more'一下或读参考文献[1]获取更多的有关 /proc 目录中的文件的信息。我建议使用'more'而不是'cat'，除非你知道这个文件很小，因为有些文件 (比如 kcore) 可能会非常长。 <p>&nbsp;</p> <a rel="nofollow">&nbsp;</a> <h2>有关运行中的进程的信息</h2> <p>/proc 文件系统可以用于获取运行中的进程的信息。在 /proc 中有一些编号的子目录。每个编号的目录对应一个进程 id (PID)。这样，每一个运行中的进程 /proc 中都有一个用它的 PID 命名的目录。这些子目录中包含可以提供有关进程的状态和环境的重要细节信息的文件。让我们试着查找一个运行中的进程。 </p> <pre>$ ps -aef | grep mozilla
root 32558 32425 8  22:53 pts/1  00:01:23  /usr/bin/mozilla
</pre> 上述命令显示有一个正在运行的 mozilla 进程的 PID 是 32558。相对应的，/proc 中应该有一个名叫 32558 的目录<br><br> <pre>$ ls -l /proc/32558
total 0
-r--r--r--    1 root  root            0 Dec 25 22:59 cmdline
-r--r--r--    1 root  root            0 Dec 25 22:59 cpu
lrwxrwxrwx    1 root  root            0 Dec 25 22:59 cwd -&gt; /proc/
-r--------    1 root  root            0 Dec 25 22:59 environ
lrwxrwxrwx    1 root  root            0 Dec 25 22:59 exe -&gt; /usr/bin/mozilla*
dr-x------    2 root  root            0 Dec 25 22:59 fd/
-r--r--r--    1 root  root            0 Dec 25 22:59 maps
-rw-------    1 root  root            0 Dec 25 22:59 mem
-r--r--r--    1 root  root            0 Dec 25 22:59 mounts
lrwxrwxrwx    1 root  root            0 Dec 25 22:59 root -&gt; //
-r--r--r--    1 root  root            0 Dec 25 22:59 stat
-r--r--r--    1 root  root            0 Dec 25 22:59 statm
-r--r--r--    1 root  root            0 Dec 25 22:59 status
</pre> 文件 "cmdline" 包含启动进程时调用的命令行。"envir" 进程的环境变两。 "status" 是进程的状态信息，包括启动进程的用户的用户ID (UID) 和组ID(GID) ，父进程ID (PPID)，还有进程当前的状态，比如"Sleelping"和"Running"。每个进程的目录都有几个符号链接，"cwd"是指向进程当前工作目录的符号链接，"exe"指向运行的进程的可执行程序，"root"指向被这个进程看作是根目录的目录 (通常是"/")。目录"fd"包含指向进程使用的文件描述符的链接。 "cpu"仅在运行 SMP 内核时出现，里面是按 CPU 划分的进程时间。 <p>&nbsp;</p> <p>/proc/self 是一个有趣的子目录，它使得程序可以方便地使用 /proc 查找本进程地信息。/proc/self 是一个链接到 /proc 中访问 /proc 的进程所对应的 PID 的目录的符号链接。</p> <a rel="nofollow">&nbsp;</a> <h2>通过 /proc 与内核交互</h2> <p><br>上面讨论的大部分 /proc 的文件是只读的。而实际上 /proc 文件系统通过 /proc 中可读写的文件提供了对内核的交互机制。写这些文件可以改变内核的状态，因而要慎重改动这些文件。/proc/sys 目录存放所有可读写的文件的目录，可以被用于改变内核行为。</p> <p>/proc/sys/kernel - 这个目录包含反通用内核行为的信息。 /proc/sys/kernel/{domainname, hostname} 存放着机器/网络的域名和主机名。这些文件可以用于修改这些名字。</p> <pre>$ hostname
machinename.domainname.com

$ cat /proc/sys/kernel/domainname
domainname.com

$ cat /proc/sys/kernel/hostname
machinename

$ echo "new-machinename"  &gt; /proc/sys/kernel/hostname

$ hostname
new-machinename.domainname.com

</pre> 这样，通过修改 /proc 文件系统中的文件，我们可以修改主机名。很多其他可配置的文件存在于 /proc/sys/kernel/。这里不可能列出所有这些文件，读者可以自己去这个目录查看以得到更多细节信息。<br>另一个可配置的目录是 /proc/sys/net。这个目录中的文件可以用于修改机器/网络的网络属性。比如，简单修改一个文件，你可以在网络上瘾藏匿的计算机。<br><br> <pre>$ echo 1 &gt; /proc/sys/net/ipv4/icmp_echo_ignore_all
</pre> 这将在网络上瘾藏你的机器，因为它不响应 icmp_echo。主机将不会响应其他主机发出的 ping 查询。<br><br> <pre>$ ping machinename.domainname.com
no answer from machinename.domainname.com
</pre> 要改回缺省设置，只要<br> <pre>$ echo 0 &gt; /proc/sys/net/ipv4/icmp_echo_ignore_all
</pre> /proc/sys 下还有许多其它可以用于改变内核属性。读者可以通过参考文献 [1], [2] 获取更多信息。 <p>&nbsp;</p> <a rel="nofollow">&nbsp;</a> <h2>结论</h2> <p>/proc 文件系统提供了一个基于文件的 Linux 内部接口。它可以用于确定系统的各种不同设备和进程的状态。对他们进行配置。因而，理解和应用有关这个文件系统的知识是理解你的 Linux 系统的关键。</p> <a rel="nofollow">&nbsp;</a> <h2>参考文献</h2> <p>&nbsp;</p> 
     <ul> 
      <li>[1] 有关Linux proc 文件系统的文档位于: /usr/src/linux/Documentation/filesystems/proc.txt</li> 
      <li>[2] RedHat Guide: The /proc File System: <a href="http://www.redhat.com/docs/manuals/linux/RHL-7.3-Manual/ref-guide/ch-proc.html" rel="nofollow"><span style="color: #0000ff;">http://www.redhat.com/docs/manuals/linux/RHL-7.3-Manual/ref-guide/ch-proc.html</span></a> </li> 
     </ul> </span></td> 
  </tr> 
 </tbody> 
</table>

# 使用 /proc 文件系统来访问 Linux 内核的内容 #

[http://www.ibm.com/developerworks/cn/linux/l-proc.html][http_www.ibm.com_developerworks_cn_linux_l-proc.html]

<table style="width: 100%;"> 
 <tbody> 
  <tr> 
   <td> <p>这个虚拟文件系统在内核空间和用户空间之间打开了一个通信窗口</p> <img src="http://www.ibm.com/i/c.gif" alt="" width="1" height="6"></td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

<table style="width: 100%;"> 
 <tbody> 
  <tr> 
   <td><img src="http://www.ibm.com/i/c.gif" alt="" width="10" height="1"></td> 
   <td> <p>级别： 初级</p> <p><a rel="nofollow"><span style="color: #5c81a7;">M. Tim Jones</span></a> (<a href="mailto:mtj@mtjones.com?subject=使用%20/proc%20文件系统来访问%20Linux%20内核的内容&amp;cc=tomyoung@us.ibm.com" rel="nofollow"><span style="color: #5c81a7;">mtj@mtjones.com</span></a>), 资深首席软件工程师, Emulex</p> <p>2006 年 4 月 24 日</p> 
    <blockquote>
      /proc 文件系统是一个虚拟文件系统，通过它可以使用一种新的方法在 Linux® 内核空间和用户空间之间进行通信。在 /proc 文件系统中，我们可以将对虚拟文件的读写作为与内核中实体进行通信的一种手段，但是与普通文件不同的是，这些虚拟文件的内容都是动态创建的。本文对 /proc 虚拟文件系统进行了介绍，并展示了它的用法。 
    </blockquote> <p>最初开发 /proc 文件系统是为了提供有关系统中进程的信息。但是由于这个文件系统非常有用，因此内核中的很多元素也开始使用它来报告信息，或启用动态运行时配置。</p> <p>/proc 文件系统包含了一些目录（用作组织信息的方式）和虚拟文件。虚拟文件可以向用户呈现内核中的一些信息，也可以用作一种从用户空间向内核发送信息的手段。实际上我们并不会同时需要实现这两点，但是本文将向您展示如何配置这个文件系统进行输入和输出。</p> <p>尽管像本文这样短小的一篇文章无法详细介绍 /proc 的所有用法，但是它依然对这两种用法进行了展示，从而可以让我们体会一下 /proc 是多么强大。清单 1 是对 /proc 中部分元素进行一次交互查询的结果。它显示的是 /proc 文件系统的根目录中的内容。注意，在左边是一系列数字编号的文件。每个实际上都是一个目录，表示系统中的一个进程。由于在 GNU/Linux 中创建的第一个进程是 <code>init</code> 进程，因此它的 <code>process-id</code> 为 <em>1</em>。然后对这个目录执行一个 <code>ls</code> 命令，这会显示很多文件。每个文件都提供了有关这个特殊进程的详细信息。例如，要查看 <code>init</code> 的 command-line 项的内容，只需对 <code>cmdline</code> 文件执行 <code>cat</code> 命令。</p> <p>/proc 中另外一些有趣的文件有：<code>cpuinfo</code>，它标识了处理器的类型和速度；<code>pci</code>，显示在 PCI 总线上找到的设备；<code>modules</code>，标识了当前加载到内核中的模块。</p> <br><a rel="nofollow"><strong>清单 1. 对 /proc 的交互过程</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>        
[root@plato]# <span><strong>ls /proc</strong></span>
1     2040  2347  2874  474          fb           mdstat      sys
104   2061  2356  2930  9            filesystems  meminfo     sysrq-trigger
113   2073  2375  2933  acpi         fs           misc        sysvipc
1375  21    2409  2934  buddyinfo    ide          modules     tty
1395  2189  2445  2935  bus          interrupts   mounts      uptime
1706  2201  2514  2938  cmdline      iomem        mtrr        version
179   2211  2515  2947  cpuinfo      ioports      net         vmstat
180   2223  2607  3     crypto       irq          partitions
181   2278  2608  3004  devices      kallsyms     pci
182   2291  2609  3008  diskstats    kcore        self
2     2301  263   3056  dma          kmsg         slabinfo
2015  2311  2805  394   driver       loadavg      stat
2019  2337  2821  4     execdomains  locks        swaps
[root@plato 1]# <span><strong>ls /proc/1</strong></span>
auxv     cwd      exe  loginuid  mem     oom_adj    root  statm   task
cmdline  environ  fd   maps      mounts  oom_score  stat  status  wchan
[root@plato]# <span><strong>cat /proc/1/cmdline</strong></span>
init [5]
[root@plato]#
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>清单 2 展示了对 /proc 中的一个虚拟文件进行读写的过程。这个例子首先检查内核的 TCP/IP 栈中的 IP 转发的目前设置，然后再启用这种功能。</p> <br><a rel="nofollow"><strong>清单 2. 对 /proc 进行读写（配置内核）</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>        
[root@plato]# <span><strong>cat /proc/sys/net/ipv4/ip_forward</strong></span>
0
[root@plato]# <span><strong>echo "1" &gt; /proc/sys/net/ipv4/ip_forward</strong></span>
[root@plato]# <span><strong>cat /proc/sys/net/ipv4/ip_forward</strong></span>
1
[root@plato]#
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>另外，我们还可以使用 <code>sysctl</code> 来配置这些内核条目。有关这个问题的更多信息，请参阅 <a rel="nofollow"><span style="color: #5c81a7;">参考资料</span></a> 一节的内容。</p> <p>顺便说一下，/proc 文件系统并不是 GNU/Linux 系统中的惟一一个虚拟文件系统。在这种系统上，<em>sysfs</em> 是一个与 /proc 类似的文件系统，但是它的组织更好（从 /proc 中学习了很多教训）。不过 /proc 已经确立了自己的地位，因此即使 sysfs 与 /proc 相比有一些优点，/proc 也依然会存在。还有一个 <em>debugfs</em> 文件系统，不过（顾名思义）它提供的更多是调试接口。debugfs 的一个优点是它将一个值导出给用户空间非常简单（实际上这不过是一个调用而已）。</p> <p><a rel="nofollow"><span>内核模块简介</span></a></p> <p>可加载内核模块（LKM）是用来展示 /proc 文件系统的一种简单方法，这是因为这是一种用来动态地向 Linux 内核添加或删除代码的新方法。LKM 也是 Linux 内核中为设备驱动程序和文件系统使用的一种流行机制。</p> <p>如果您曾经重新编译过 Linux 内核，就可能会发现在内核的配置过程中，有很多设备驱动程序和其他内核元素都被编译成了模块。如果一个驱动程序被直接编译到了内核中，那么即使这个驱动程序没有运行，它的代码和静态数据也会占据一部分空间。但是如果这个驱动程序被编译成一个模块，就只有在需要内存并将其加载到内核时才会真正占用内存空间。有趣的是，对于 LKM 来说，我们不会注意到有什么性能方面的差异，因此这对于创建一个适应于自己环境的内核来说是一种功能强大的手段，这样可以根据可用硬件和连接的设备来加载对应的模块。</p> <p>下面是一个简单的 LKM，可以帮助您理解它与在 Linux 内核中看到的标准（非动态可加载的）代码之间的区别。清单 3 给出了一个最简单的 LKM。（可以从本文的 <a rel="nofollow"><span style="color: #5c81a7;">下载</span></a> 一节中下载这个代码）。</p> <p>清单 3 包括了必须的模块头（它定义了模块的 API、类型和宏）。然后使用 <code>MODULE_LICENSE</code> 定义了这个模块使用的许可证。此处，我们定义的是 <em>GPL</em>，从而防止会污染到内核。</p> <p>清单 3 然后又定义了这个模块的 <code>init</code> 和 <code>cleanup</code> 函数。<code>my_module_init</code> 函数是在加载这个模块时被调用的，它用来进行一些初始化方面的工作。<code>my_module_cleanup</code> 函数是在卸载这个模块时被调用的，它用来释放内存并清除这个模块的踪迹。注意此处 <code>printk</code> 的用法：这是内核的 <code>printf</code> 函数。<code>KERN_INFO</code> 符号是一个字符串，可以用来对进入内核回环缓冲区的信息进行过滤（非常类似于 <code>syslog</code>）。</p> <p>最后，清单 3 使用 <code>module_init</code> 和 <code>module_exit</code> 宏声明了入口函数和出口函数。这样我们就可以按照自己的意愿来对这个模块的 <code>init</code> 和 <code>cleanup</code> 函数进行命名了，不过我们最终要告诉内核维护函数就是这些函数。</p> <br><a rel="nofollow"><strong>清单 3. 一个简单的但可以正常工作的 LKM（simple-lkm.c）</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>        
#include &lt;linux/module.h&gt;
/* Defines the license for this LKM */
<span><strong>MODULE_LICENSE</strong></span>("GPL");
/* Init function called on module entry */
int my_module_init( void )
{
  printk(KERN_INFO "my_module_init called.  Module is now loaded./n");
  return 0;
}
/* Cleanup function called on module exit */
void my_module_cleanup( void )
{
  printk(KERN_INFO "my_module_cleanup called.  Module is now unloaded./n");
  return;
}
/* Declare entry and exit functions */
<span><strong>module_init</strong></span>( my_module_init );
<span><strong>module_exit</strong></span>( my_module_cleanup );
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>清单 3 尽管非常简单，但它却是一个真正的 LKM。现在让我们对其进行编译并在一个 2.6 版本的内核上进行测试。2.6 版本的内核为内核模块的编译引入了一种新方法，我发现这种方法比原来的方法简单了很多。对于文件 <code>simple-lkm.c</code>，我们可以创建一个 makefile，其惟一内容如下：</p> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>obj-m += simple-lkm.o
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>要编译 LKM，请使用 <code>make</code> 命令，如清单 4 所示。</p> <br><a rel="nofollow"><strong>清单 4. 编译 LKM</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>        
[root@plato]# <span><strong>make -C /usr/src/linux-`uname -r` SUBDIRS=$PWD modules</strong></span>
make: Entering directory `/usr/src/linux-2.6.11'
  CC [M]  /root/projects/misc/module2.6/simple/simple-lkm.o
  Building modules, stage 2.
  MODPOST
  CC      /root/projects/misc/module2.6/simple/simple-lkm.mod.o
  LD [M]  /root/projects/misc/module2.6/simple/simple-lkm.ko
make: Leaving directory `/usr/src/linux-2.6.11'
[root@plato]#
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>结果会生成一个 <code>simple-lkm.ko</code> 文件。这个新的命名约定可以帮助将这些内核对象（LKM）与标准对象区分开来。现在可以加载或卸载这个模块了，然后可以查看它的输出。要加载这个模块，请使用 <code>insmod</code> 命令；反之，要卸载这个模块，请使用 <code>rmmod</code> 命令。<code>lsmod</code> 可以显示当前加载的 LKM（参见清单 5）。</p> <br><a rel="nofollow"><strong>清单 5. 插入、检查和删除 LKM</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>        
[root@plato]# <span><strong>insmod simple-lkm.ko</strong></span>
[root@plato]# <span><strong>lsmod</strong></span>
Module                  Size  Used by
simple_lkm              1536  0
autofs4                26244  0
video                  13956  0
button                  5264  0
battery                 7684  0
ac                      3716  0
yenta_socket           18952  3
rsrc_nonstatic          9472  1 yenta_socket
uhci_hcd               32144  0
i2c_piix4               7824  0
dm_mod                 56468  3
[root@plato]# <span><strong>rmmod simple-lkm</strong></span>
[root@plato]#
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>注意，内核的输出进到了内核回环缓冲区中，而不是打印到 <code>stdout</code> 上，这是因为 <code>stdout</code> 是进程特有的环境。要查看内核回环缓冲区中的消息，可以使用 <code>dmesg</code> 工具（或者通过 /proc 本身使用 <code>cat /proc/kmsg</code> 命令）。清单 6 给出了 <code>dmesg</code> 显示的最后几条消息。</p> <br><a rel="nofollow"><strong>清单 6. 查看来自 LKM 的内核输出</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>        
[root@plato]# <span><strong>dmesg | tail -5</strong></span>
cs: IO port probe 0xa00-0xaff: clean.
eth0: Link is down
eth0: Link is up, running at 100Mbit half-duplex
my_module_init called.  Module is now loaded.
my_module_cleanup called.  Module is now unloaded.
[root@plato]#
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>可以在内核输出中看到这个模块的消息。现在让我们暂时离开这个简单的例子，来看几个可以用来开发有用 LKM 的内核 API。</p> <br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/v14/rules/blue_rule.gif" alt="" width="100%" height="1"><br><img src="http://www.ibm.com/i/c.gif" alt="" width="8" height="6"></td> 
      </tr> 
     </tbody> 
    </table> 
    <table> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/c.gif" alt="" width="100%" height="4"><br></td> 
      </tr> 
     </tbody> 
    </table> <br><br> <p><a rel="nofollow"><span>集成到 /proc 文件系统中</span></a></p> <p>内核程序员可以使用的标准 API，LKM 程序员也可以使用。LKM 甚至可以导出内核使用的新变量和函数。有关 API 的完整介绍已经超出了本文的范围，因此我们在这里只是简单地介绍后面在展示一个更有用的 LKM 时所使用的几个元素。 </p> <p><a rel="nofollow"><span><strong><span style="font-family: Arial; font-size: small;">创建并删除 /proc 项</span></strong></span></a></p> <p>要在 /proc 文件系统中创建一个虚拟文件，请使用 <code>create_proc_entry</code> 函数。这个函数可以接收一个文件名、一组权限和这个文件在 /proc 文件系统中出现的位置。<code>create_proc_entry</code> 的返回值是一个 <code>proc_dir_entry</code> 指针（或者为 <em>NULL</em>，说明在 <code>create</code> 时发生了错误）。然后就可以使用这个返回的指针来配置这个虚拟文件的其他参数，例如在对该文件执行读操作时应该调用的函数。<code>create_proc_entry</code> 的原型和 <code>proc_dir_entry</code> 结构中的一部分如清单 7 所示。</p> <br><a rel="nofollow"><strong>清单 7. 用来管理 /proc 文件系统项的元素</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>        
struct proc_dir_entry *<span><strong>create_proc_entry</strong></span>( const char *name, mode_t mode,
                                             struct proc_dir_entry *parent );
struct <span><strong>proc_dir_entry</strong></span> {
	const char *name;			// virtual file name
	mode_t mode;				// mode permissions
	uid_t uid;				// File's user id
	gid_t gid;				// File's group id
	struct inode_operations *proc_iops;	// Inode operations functions
	struct file_operations *proc_fops;	// File operations functions
	struct proc_dir_entry *parent;		// Parent directory
	...
	read_proc_t *read_proc;			// /proc read function
	write_proc_t *write_proc;		// /proc write function
	void *data;				// Pointer to private data
	atomic_t count;				// use count
	...
};
void <span><strong>remove_proc_entry</strong></span>( const char *name, struct proc_dir_entry *parent );
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>稍后我们就可以看到如何使用 <code>read_proc</code> 和 <code>write_proc</code> 命令来插入对这个虚拟文件进行读写的函数。 </p> <p>要从 /proc 中删除一个文件，可以使用 <code>remove_proc_entry</code> 函数。要使用这个函数，我们需要提供文件名字符串，以及这个文件在 /proc 文件系统中的位置（parent）。这个函数原型如清单 7 所示。</p> <p>parent 参数可以为 NULL（表示 /proc 根目录），也可以是很多其他值，这取决于我们希望将这个文件放到什么地方。表 1 列出了可以使用的其他一些父 <code>proc_dir_entry</code>，以及它们在这个文件系统中的位置。</p> <br><a rel="nofollow"><strong>表 1. proc_dir_entry 快捷变量</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <th>proc_dir_entry</th> 
       <th>在文件系统中的位置</th> 
      </tr> 
      <tr> 
       <td><code>proc_root_fs</code></td> 
       <td><code>/proc</code></td> 
      </tr> 
      <tr> 
       <td><code>proc_net</code></td> 
       <td><code>/proc/net</code></td> 
      </tr> 
      <tr> 
       <td><code>proc_bus</code></td> 
       <td><code>/proc/bus</code></td> 
      </tr> 
      <tr> 
       <td><code>proc_root_driver</code></td> 
       <td><code>/proc/driver</code></td> 
      </tr> 
     </tbody> 
    </table> <br> <p><a rel="nofollow"><span><strong><span style="font-family: Arial; font-size: small;">回调函数</span></strong></span></a></p> <p>我们可以使用 <code>write_proc</code> 函数向 /proc 中写入一项。这个函数的原型如下：</p> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>int mod_write( struct file *filp, const char __user *buff,
               unsigned long len, void *data );
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p><code>filp</code> 参数实际上是一个打开文件结构（我们可以忽略这个参数）。<code>buff</code> 参数是传递给您的字符串数据。缓冲区地址实际上是一个用户空间的缓冲区，因此我们不能直接读取它。<code>len</code> 参数定义了在 <code>buff</code> 中有多少数据要被写入。<code>data</code> 参数是一个指向私有数据的指针（参见 <a rel="nofollow"><span style="color: #5c81a7;">清单 7</span></a>）。在这个模块中，我们声明了一个这种类型的函数来处理到达的数据。</p> <p>Linux 提供了一组 API 来在用户空间和内核空间之间移动数据。对于 <code>write_proc</code> 的情况来说，我们使用了 <code>copy_from_user</code> 函数来维护用户空间的数据。</p> <p><a rel="nofollow"><span><strong><span style="font-family: Arial; font-size: small;">读回调函数</span></strong></span></a></p> <p>我们可以使用 <code>read_proc</code> 函数从一个 /proc 项中读取数据（从内核空间到用户空间）。这个函数的原型如下：</p> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>int mod_read( char *page, char **start, off_t off,
              int count, int *eof, void *data );
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p><code>page</code> 参数是这些数据写入到的位置，其中 <code>count</code> 定义了可以写入的最大字符数。在返回多页数据（通常一页是 4KB）时，我们需要使用 <code>start</code> 和 <code>off</code> 参数。当所有数据全部写入之后，就需要设置 <code>eof</code>（文件结束参数）。与 <code>write</code> 类似，<code>data</code> 表示的也是私有数据。此处提供的 <code>page</code> 缓冲区在内核空间中。因此，我们可以直接写入，而不用调用 <code>copy_to_user</code>。</p> <p><a rel="nofollow"><span><strong><span style="font-family: Arial; font-size: small;">其他有用的函数</span></strong></span></a></p> <p>我们还可以使用 <code>proc_mkdir</code>、<code>symlinks</code> 以及 <code>proc_symlink</code> 在 /proc 文件系统中创建目录。对于只需要一个 <code>read</code> 函数的简单 /proc 项来说，可以使用 <code>create_proc_read_entry</code>，这会创建一个 /proc 项，并在一个调用中对 <code>read_proc</code> 函数进行初始化。这些函数的原型如清单 8 所示。 </p> <br><a rel="nofollow"><strong>清单 8. 其他有用的 /proc 函数</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>        
/* Create a directory in the proc filesystem */
struct proc_dir_entry <span><strong>*proc_mkdir</strong></span>( const char *name,
                                     struct proc_dir_entry *parent );
/* Create a symlink in the proc filesystem */
struct proc_dir_entry *<span><strong>proc_symlink</strong></span>( const char *name,
                                       struct proc_dir_entry *parent,
                                       const char *dest );
/* Create a proc_dir_entry with a read_proc_t in one call */
struct proc_dir_entry *<span><strong>create_proc_read_entry</strong></span>( const char *name,
                                                  mode_t mode,
                                                  struct proc_dir_entry *base,
                                                  read_proc_t *read_proc,
                                                  void *data );
/* Copy buffer to user-space from kernel-space */
unsigned long <span><strong>copy_to_user</strong></span>( void __user *to,
                              const void *from,
                              unsigned long n );
/* Copy buffer to kernel-space from user-space */
unsigned long <span><strong>copy_from_user</strong></span>( void *to,
                                const void __user *from,
                                unsigned long n );
/* Allocate a 'virtually' contiguous block of memory */
void *<span><strong>vmalloc</strong></span>( unsigned long size );
/* Free a vmalloc'd block of memory */
void <span><strong>vfree</strong></span>( void *addr );
/* Export a symbol to the kernel (make it visible to the kernel) */
<span><strong>EXPORT_SYMBOL</strong></span>( symbol );
/* Export all symbols in a file to the kernel (declare before module.h) */
<span><strong>EXPORT_SYMTAB</strong></span>
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/v14/rules/blue_rule.gif" alt="" width="100%" height="1"><br><img src="http://www.ibm.com/i/c.gif" alt="" width="8" height="6"></td> 
      </tr> 
     </tbody> 
    </table> 
    <table> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/c.gif" alt="" width="100%" height="4"><br></td> 
      </tr> 
     </tbody> 
    </table> <br><br> <p><a rel="nofollow"><span>通过 /proc 文件系统实现财富分发</span></a></p> <p>下面是一个可以支持读写的 LKM。这个简单的程序提供了一个财富甜点分发。在加载这个模块之后，用户就可以使用 <code>echo</code> 命令向其中导入文本财富，然后再使用 <code>cat</code> 命令逐一读出。</p> <p>清单 9 给出了基本的模块函数和变量。<code>init</code> 函数（<code>init_fortune_module</code>）负责使用 <code>vmalloc</code> 来为这个点心罐分配空间，然后使用 <code>memset</code> 将其全部清零。使用所分配并已经清空的 <code>cookie_pot</code> 内存，我们在 /proc 中创建了一个 <code>proc_dir_entry</code> 项，并将其称为 <em>fortune</em>。当 <code>proc_entry</code> 成功创建之后，对自己的本地变量和 <code>proc_entry</code> 结构进行了初始化。我们加载了 /proc <code>read</code> 和 <code>write</code> 函数（如清单 9 和清单 10 所示），并确定这个模块的所有者。<code>cleanup</code> 函数简单地从 /proc 文件系统中删除这一项，然后释放 <code>cookie_pot</code> 所占据的内存。</p> <p><code>cookie_pot</code> 是一个固定大小（4KB）的页，它使用两个索引进行管理。第一个是 <code>cookie_index</code>，标识了要将下一个 cookie 写到哪里去。变量 <code>next_fortune</code> 标识了下一个 cookie 应该从哪里读取以便进行输出。在所有的 fortune 项都读取之后，我们简单地回到了 <code>next_fortune</code>。</p> <br><a rel="nofollow"><strong>清单 9. 模块的 init/cleanup 和变量</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>        
#include &lt;linux/module.h&gt;
#include &lt;linux/kernel.h&gt;
#include &lt;linux/proc_fs.h&gt;
#include &lt;linux/string.h&gt;
#include &lt;linux/vmalloc.h&gt;
#include &lt;asm/uaccess.h&gt;
<span><strong>MODULE_LICENSE</strong></span>("GPL");
<span><strong>MODULE_DESCRIPTION</strong></span>("Fortune Cookie Kernel Module");
<span><strong>MODULE_AUTHOR</strong></span>("M. Tim Jones");
#define MAX_COOKIE_LENGTH       PAGE_SIZE
static struct proc_dir_entry *proc_entry;
static char *cookie_pot;  // Space for fortune strings
static int cookie_index;  // Index to write next fortune
static int next_fortune;  // Index to read next fortune
int init_fortune_module( void )
{
  int ret = 0;
  cookie_pot = (char *)<span><strong>vmalloc</strong></span>( MAX_COOKIE_LENGTH );
  if (!cookie_pot) {
    ret = -ENOMEM;
  } else {
    memset( cookie_pot, 0, MAX_COOKIE_LENGTH );
    proc_entry = <span><strong>create_proc_entry</strong></span>( "fortune", 0644, NULL );
    if (proc_entry == NULL) {
      ret = -ENOMEM;
      <span><strong>vfree</strong></span>(cookie_pot);
      printk(KERN_INFO "fortune: Couldn't create proc entry/n");
    } else {
      cookie_index = 0;
      next_fortune = 0;
      proc_entry-&gt;read_proc = fortune_read;
      proc_entry-&gt;write_proc = fortune_write;
      proc_entry-&gt;owner = THIS_MODULE;
      printk(KERN_INFO "fortune: Module loaded./n");
    }
  }
  return ret;
}
void cleanup_fortune_module( void )
{
  <span><strong>remove_proc_entry</strong></span>("fortune", &amp;proc_root);
  <span><strong>vfree</strong></span>(cookie_pot);
  printk(KERN_INFO "fortune: Module unloaded./n");
}
<span><strong>module_init</strong></span>( init_fortune_module );
<span><strong>module_exit</strong></span>( cleanup_fortune_module );
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>向这个罐中新写入一个 cookie 非常简单（如清单 10 所示）。使用这个写入 cookie 的长度，我们可以检查是否有这么多空间可用。如果没有，就返回 <code>-ENOSPC</code>，它会返回给用户空间。否则，就说明空间存在，我们使用 <code>copy_from_user</code> 将用户缓冲区中的数据直接拷贝到 <code>cookie_pot</code> 中。然后增大 <code>cookie_index</code>（基于用户缓冲区的长度）并使用 NULL 来结束这个字符串。最后，返回实际写入 <code>cookie_pot</code> 的字符的个数，它会返回到用户进程。</p> <br><a rel="nofollow"><strong>清单 10. 对 fortune 进行写入操作所使用的函数</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>        
ssize_t fortune_write( struct file *filp, const char __user *buff,
                        unsigned long len, void *data )
{
  int space_available = (MAX_COOKIE_LENGTH-cookie_index)+1;
  if (len &gt; space_available) {
    printk(KERN_INFO "fortune: cookie pot is full!/n");
    return -ENOSPC;
  }
  if (<span><strong>copy_from_user</strong></span>( &amp;cookie_pot[cookie_index], buff, len )) {
    return -EFAULT;
  }
  cookie_index += len;
  cookie_pot[cookie_index-1] = 0;
  return len;
}
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>对 fortune 进行读取也非常简单，如清单 11 所示。由于我们刚才写入数据的缓冲区（<code>page</code>）已经在内核空间中了，因此可以直接对其进行操作，并使用 <code>sprintf</code> 来写入下一个 fortune。如果 <code>next_fortune</code> 索引大于 <code>cookie_index</code>（要写入的下一个位置），那么我们就将 <code>next_fortune</code> 返回为 0，这是第一个 fortune 的索引。在将这个 fortune 写入用户缓冲区之后，在 <code>next_fortune</code> 索引上增加刚才写入的 fortune 的长度。这样就变成了下一个可用 fortune 的索引。这个 fortune 的长度会被返回并传递给用户。</p> <br><a rel="nofollow"><strong>清单 11. 对 fortune 进行读取操作所使用的函数</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>        
int fortune_read( char *page, char **start, off_t off,
                   int count, int *eof, void *data )
{
  int len;
  if (off &gt; 0) {
    *eof = 1;
    return 0;
  }
  /* Wrap-around */
  if (next_fortune &gt;= cookie_index) next_fortune = 0;
  len = sprintf(page, "%s/n", &amp;cookie_pot[next_fortune]);
  next_fortune += len;
  return len;
}
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>从这个简单的例子中，我们可以看出通过 /proc 文件系统与内核进行通信实际上是件非常简单的事情。现在让我们来看一下这个 fortune 模块的用法（参见清单 12）。</p> <br><a rel="nofollow"><strong>清单 12. 展示 fortune cookie LKM 的用法</strong></a><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td> <pre>        
[root@plato]# <span><strong>insmod fortune.ko</strong></span>
[root@plato]# <span><strong>echo "Success is an individual proposition. Thomas Watson" &gt; /proc/fortune</strong></span>
[root@plato]# <span><strong>echo "If a man does his best, what else is there? Gen. Patton" &gt; /proc/fortune</strong></span>
[root@plato]# <span><strong>echo "Cats: All your base are belong to us. Zero Wing" &gt; /proc/fortune</strong></span>
[root@plato]# <span><strong>cat /proc/fortune</strong></span>
Success is an individual proposition.  Thomas Watson
[root@plato]# <span><strong>cat /proc/fortune</strong></span>
If a man does his best, what else is there?  General Patton
[root@plato]#
</pre> </td> 
      </tr> 
     </tbody> 
    </table> <br> <p>/proc 虚拟文件系统可以广泛地用来报告内核的信息，也可以用来进行动态配置。我们会发现它对于驱动程序和模块编程来说都是非常完整的。在下面的 <a rel="nofollow"><span style="color: #5c81a7;">参考资料</span></a> 中，我们可以学习到更多相关知识。</p> <br><br> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/v14/rules/blue_rule.gif" alt="" width="100%" height="1"><br><img src="http://www.ibm.com/i/c.gif" alt="" width="8" height="6"></td> 
      </tr> 
     </tbody> 
    </table> 
    <table> 
     <tbody> 
      <tr> 
       <td><img src="http://www.ibm.com/i/c.gif" alt="" width="100%" height="4"><br></td> 
      </tr> 
     </tbody> 
    </table> <br><br> <p><span><a rel="nofollow">下载</a></span></p> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <th>描述</th> 
       <th>名字</th> 
       <th>大小</th> 
       <th>下载方法</th> 
      </tr> 
      <tr> 
       <th>Linux kernel module source</th> 
       <td>l-proc-lkm.zip</td> 
       <td>2KB</td> 
       <td><a href="http://download.boulder.ibm.com/ibmdl/pub/software/dw/linux/l-proc-lkm.zip" rel="nofollow"><strong><span style="color: #5c81a7;">HTTP</span></strong></a></td> 
      </tr> 
     </tbody> 
    </table> <br> <p><a rel="nofollow"><span>参考资料 </span></a></p> <strong>学习</strong><br> 
    <ul> 
     <li>您可以参阅本文在 developerWorks 全球站点上的 <a href="http://www.ibm.com/developerworks/linux/library/l-proc.html?S_TACT=105AGX52&amp;S_CMP=cn-a-l" rel="nofollow"><span style="color: #5c81a7;">英文原文</span></a>。</li> 
     <li>“<a href="http://www.ibm.com/developerworks/cn/linux/l-adfly/index.html" rel="nofollow"><span style="color: #5c81a7;">实时管理 Linux</span></a>”（developerWorks，2003 年 5 月）详细介绍了 /proc 的基础知识，包括如何管理操作系统的众多细节，而不用关闭或重新启动机器。 </li> 
     <li>探索 /proc 文件系统中的 <a href="http://www.comptechdoc.org/os/linux/howlinuxworks/linux_hlproc.html" rel="nofollow"><span style="color: #5c81a7;">文件和子目录</span></a>。 </li> 
     <li>有关 Linux 内核 2.6 版本的 <a href="http://lwn.net/Articles/22197/" rel="nofollow"><span style="color: #5c81a7;">driver porting</span></a> 的文章详细讨论了内核模块的问题。 </li> 
     <li><a href="http://www.linuxhq.com/index.html" rel="nofollow"><span style="color: #5c81a7;">LinuxHQ</span></a> 是有关 Linux 内核信息的一个很好站点。 </li> 
     <li><a href="http://lwn.net/Articles/115405/" rel="nofollow"><span style="color: #5c81a7;">debugfs</span></a> 文件系统是除 /proc 之外另外一个调试选择。 </li> 
     <li>“<a href="http://www.ibm.com/developerworks/cn/linux/l-dev26/" rel="nofollow"><span style="color: #5c81a7;">内核比较: 从 2.4 到 2.6 内核开发中的改进</span></a>” （developerWorks，2004 年 2 月）对构成 2.6 版本内核的工具、测试以及技术进行了深入介绍。 </li> 
     <li>“<a href="http://www.ibm.com/developerworks/cn/linux/l-kprobes.html" rel="nofollow"><span style="color: #5c81a7;">使用 Kprobes 调试内核</span></a>” （developerWorks，2004 年 8 月）介绍了 Kprobes 如何与 2.6 版本的内核结合使用，提供一种轻量级的非破坏性的强大机制来动态插入 <code>printk</code> 函数。 </li> 
     <li><code>printk</code> 函数和 <code>dmesg</code> 方法都是用来进行内核调试的常用方法。Allessando Rubini 撰写的 <em>Linux Device Drivers</em> 一书提供了一章有关内核调试技术的 <a href="http://www.xml.com/ldd/chapter/book/ch04.html" rel="nofollow"><span style="color: #5c81a7;">在线内容</span></a>。 </li> 
     <li><a href="http://www.samag.com/documents/s=8920/sam0311a/0311a.htm" rel="nofollow"><span style="color: #5c81a7;">sysctl</span></a> 命令是另外一种实现动态内核配置的方法。 </li> 
     <li>在 <a href="http://www.ibm.com/developerworks/cn/linux/" rel="nofollow"><span style="color: #5c81a7;">developerWorks Linux 专区</span></a> 中可以找到为 Linux 开发人员准备的更多参考资料。 </li> 
     <li>随时关注 <a href="http://www.ibm.com/developerworks/offers/techbriefings/?S_TACT=105AGX52&amp;S_CMP=cn-a-l" rel="nofollow"><span style="color: #5c81a7;">developerWorks 技术活动和网络广播</span></a>。 </li> 
    </ul> <br><strong>获得产品和技术</strong><br> 
    <ul> 
     <li><a href="http://www.kernel.org/" rel="nofollow"><span style="color: #5c81a7;">kernel.org</span></a> 上提供最新的 Linux 内核。 </li> 
     <li><a href="http://www.gnu.org/software/make/manual/make.html" rel="nofollow"><span style="color: #5c81a7;">GNU make 工具文档</span></a> 在 <a href="http://www.gnu.org/" rel="nofollow"><span style="color: #5c81a7;">gnu.org 站点</span></a> 上可以找到。 </li> 
     <li><a href="http://www.faqs.org/docs/linux_scratch/appendixa/modutils.html" rel="nofollow"><span style="color: #5c81a7;">Modutils</span></a> 包提供了很多有关内核模块的工具。 </li> 
     <li><a href="http://www.ibm.com/developerworks/offers/sek/?S_TACT=105AGX52&amp;S_CMP=cn-a-l" rel="nofollow"><span style="color: #5c81a7;">索取免费的 SEK for Linux</span></a>，这有两张 DVD，包括最新的 IBM for Linux 试用版软件，包括 DB2®、Lotus®、Rational®、Tivoli® 和 WebSphere®。 </li> 
     <li>用可直接从 developerWorks 下载的 <a href="http://www.ibm.com/developerworks/downloads/?S_TACT=105AGX52&amp;S_CMP=cn-a-l" rel="nofollow"><span style="color: #5c81a7;">IBM 试用软件</span></a> 构建您的下一个开发项目。<br></li> 
    </ul> <br><strong>讨论</strong><br> 
    <ul> 
     <li>通过参与 <a href="http://www.ibm.com/developerworks/blogs/?S_TACT=105AGX52&amp;S_CMP=cn-a-l" rel="nofollow"><span style="color: #5c81a7;">developerWorks blogs</span></a> 加入 developerWorks 社区。</li> 
    </ul> <p><a rel="nofollow"><span>关于作者</span></a></p> <p> </p> 
    <table style="width: 100%;"> 
     <tbody> 
      <tr> 
       <td colspan="3"><img src="http://www.ibm.com/i/c.gif" alt="" width="100%" height="5"></td> 
      </tr> 
      <tr> 
       <td> <p><img src="http://www.ibm.com/developerworks/i/p-mjones.jpg" alt="M. Tim Jones" width="64" height="80" align="left"></p> </td> 
       <td><img src="http://www.ibm.com/i/c.gif" alt="" width="4" height="5"></td> 
       <td> <p>M. Tim Jones 是一名嵌入式软件工程师，他是 <em>GNU/Linux Application Programming</em>、<em>AI Application Programming</em> 和 <em>BSD Sockets Programming from a Multilanguage Perspective</em> 等书的作者。他的工程背景非常广泛，从对地同步宇宙飞船的内核开发到嵌入式架构设计，再到网络协议的开发。Tim 是 Emulex Corp. 的一名资深软件工程师。</p> </td> 
      </tr> 
     </tbody> 
    </table> <p></p> </td> 
  </tr> 
 </tbody> 
</table>

[http_linux.chinaunix.net_doc_2004-10-05_16.shtml]: http://linux.chinaunix.net/doc/2004-10-05/16.shtml
[http_www.ibm.com_developerworks_cn_linux_l-proc.html]: http://www.ibm.com/developerworks/cn/linux/l-proc.html