<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>陈志伟博客 &#187; Linux</title>
	<atom:link href="http://chenzhiwei.net/tag/linux/feed/" rel="self" type="application/rss+xml" />
	<link>http://chenzhiwei.net</link>
	<description>善始者实繁，克终者盖寡。</description>
	<lastBuildDate>Sat, 17 Mar 2012 04:16:44 +0000</lastBuildDate>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.3.1</generator>
		<item>
		<title>Shell I/O重定向</title>
		<link>http://chenzhiwei.net/2011/08/shell-io-redirection/</link>
		<comments>http://chenzhiwei.net/2011/08/shell-io-redirection/#comments</comments>
		<pubDate>Mon, 29 Aug 2011 11:23:39 +0000</pubDate>
		<dc:creator>zhiwei</dc:creator>
				<category><![CDATA[编程相关]]></category>
		<category><![CDATA[IO]]></category>
		<category><![CDATA[Linux]]></category>
		<category><![CDATA[shell]]></category>

		<guid isPermaLink="false">http://chenzhiwei.net/?p=30432</guid>
		<description><![CDATA[Unuix/Linux系统有三个文件是默认被打开着的，它们的分别是stdin(标准输入文件，键盘)，stdout（标准输出文件，屏幕）和stderr（标准错误文件，屏幕）。这些文件和其他打开的文件都可以被重定向。I/O重定向简单的说就是用一个脚本来捕获一个文件、命令、程序、脚本甚至是代码块的输出，然后将该输出写入到另一个文件、命令、程序或脚本。 每个打开的文件都被赋予一个文件描述符。0,1,2分别是标准输入、标准输出、标准错误的文件描述符。 1. 标准输出 &#62; (COMMAND_OUTPUT &#62;) 重定向标准输出到一个文件，如果这个文件不存在则创建，存在则覆盖。 ls -lR &#62; dir-tree.list # 将当前目录的目录树写入文件dir-tree.list : &#62; filename # 删除filename里的所有内容（即将filename置空）。如果文件不存在则创建一个空文件（与touch filename命令效果相同）。 &#62; filename # 与上条命令意思相同，但是该命令在某些shell中不可用。 2. 标准输出 &#62;&#62; (COMMAND_OUTPUT &#62;&#62;) 重定标准输出到一个文件，如果该文件不存在则创建，存在则追加到该文件末尾。 只对单行重定向命令起作用（即只对命令所在的行起作用） 1 &#62;&#62; filename # 重定向并追加标准输出到filename 2 &#62;&#62; filename # 重定向前追加标准错误输出到filename &#38; &#62; filename # 重定向标准输出和标准错误输出到filename，该命令可在Bash 4下使用。 M &#62; N # “M” 是一个文件描述符，默认为1；”N”是一个文件名。意思是将M的内容重定向到N M&#62;&#38;N # [...]]]></description>
			<content:encoded><![CDATA[<p>Unuix/Linux系统有三个文件是默认被打开着的，它们的分别是stdin(标准输入文件，键盘)，stdout（标准输出文件，屏幕）和stderr（标准错误文件，屏幕）。这些文件和其他打开的文件都可以被重定向。I/O重定向简单的说就是用一个脚本来捕获一个文件、命令、程序、脚本甚至是代码块的输出，然后将该输出写入到另一个文件、命令、程序或脚本。<span id="more-30432"></span></p>
<p>每个打开的文件都被赋予一个文件描述符。0,1,2分别是标准输入、标准输出、标准错误的文件描述符。</p>
<p><strong>1. 标准输出 &gt; </strong>(COMMAND_OUTPUT &gt;)<br />
重定向标准输出到一个文件，如果这个文件不存在则创建，存在则覆盖。</p>
<p>ls -lR &gt; dir-tree.list<br />
# 将当前目录的目录树写入文件dir-tree.list</p>
<p>: &gt; filename<br />
# 删除filename里的所有内容（即将filename置空）。如果文件不存在则创建一个空文件（与touch filename命令效果相同）。</p>
<p>&gt; filename<br />
# 与上条命令意思相同，但是该命令在某些shell中不可用。</p>
<p><strong>2. 标准输出 &gt;&gt; (COMMAND_OUTPUT &gt;&gt;)</strong><br />
重定标准输出到一个文件，如果该文件不存在则创建，存在则追加到该文件末尾。</p>
<p>只对单行重定向命令起作用（即只对命令所在的行起作用）<br />
1 &gt;&gt; filename<br />
# 重定向并追加标准输出到filename</p>
<p>2 &gt;&gt; filename<br />
# 重定向前追加标准错误输出到filename</p>
<p>&amp; &gt; filename<br />
# 重定向标准输出和标准错误输出到filename，该命令可在Bash 4下使用。</p>
<p>M &gt; N<br />
# “M” 是一个文件描述符，默认为1；”N”是一个文件名。意思是将M的内容重定向到N</p>
<p>M&gt;&amp;N<br />
# “M”是一个文件描述符，默认为1；”N”是另一个文件描述符。意思是将文件描述符M重定向到N，即所有M指向的文件输出都会发给N所指向的文件。</p>
<p>2&gt;&amp;1<br />
# 将标准错误输出重定向到标准输出，一般用法如下：<br />
&gt;&gt; filename 2&gt;&amp;1<br />
# 意思是将标准错误输出重定向到标准输出，再将标准输出重定向到文件filename</p>
<p>&gt;&amp;j<br />
# 等价于 1&gt;&amp;j ，即将标准输出定向到j所指向的文件</p>
<p>0&lt;filename 或 &lt;filename<br />
# 以文件filename内容为标准输入。<br />
# grep search-word &lt; filename</p>
<p>[j]&lt;&gt;filename<br />
# 以读写方式打开filename，并且将j作为文件描述符赋值给filename，如果j没有被指定，默认为0，即标准输入。</p>
<p>下面的例子会让你更清楚理解其含义<br />
echo “1234567890&#8243; &gt; file	# 将字符串写入file<br />
exec 3&lt;&gt;file				# 打开file并且将其文件描述符设置成3<br />
read -n 4 &lt;&amp;3				# 仅读取4个字符<br />
echo -n . &gt;&amp;3				# 写入一个英文句号<br />
exec 3&gt;&amp;-				# 关于文件描述符3<br />
cat file					# 结果会是：1234.567890</p>
<p>|<br />
# 管道，用来定向命令的，与”&gt;”相似，但是更实用。不细说了。</p>
<p>ls -yz &gt;&gt; command.log 2&gt;&amp;1<br />
# 捕获非法选项yz的标准错误输出及标准输出，并写入command.log文件。</p>
<p>ls -yz 2&gt;&amp;1 &gt;&gt; command.log<br />
# 输出错误信息，但是不写入文件command.log。这一行命令的意思是将标准输出写入command.log，而标准错误输出则定向到标准输出。虽然这条命令和并一条命令一样，都是将标准错误输出定向到标准输出，但是顺序不一样，所以意义也不一样。</p>
<p><strong>3. 关闭文件描述符</strong><br />
n&lt;&amp;-<br />
# 关闭输入文件描述符n</p>
<p>0&lt;&amp;-,&lt;&amp;-<br />
# 关闭标准输入。</p>
<p>n&gt;&amp;-<br />
# 关闭标准输出文件描述符n.</p>
<p>1&gt;&amp;-,&gt;&amp;-<br />
# 关闭标准标准输出</p>
<p>子进程继承打开的文件描述符，这就是pipe工作的原理，要阻止一个文件描述符被继承，那么请关闭它。</p>
<p># 仅重定向标准错误输出到管道</p>
<p>exec 3&gt;&amp;1 						# 保存当前标准输出的值<br />
ls -l 2&gt;&amp;1 &gt;&amp;3 3&gt;&amp;- | grep bad 3&gt;&amp;-	# 为grep关闭文件描述符3（但并不是&#8217;ls&#8217;命令）<br />
exec 3&gt;&amp;- 						# 关闭文件描述符3</p>
<p>注：这是ABS Guide第20章的内容，我在上周六翻译出来的。<br />
英文原文地址：<a href="http://tldp.org/LDP/abs/html/io-redirection.html">http://tldp.org/LDP/abs/html/io-redirection.html</a></p>
<p style="font-weight: bold;">&copy; 2011, <a href="http://chenzhiwei.net">chenzhiwei.net</a>. 版权所有.  <br />本文永久链接：<a title="Shell I/O重定向" href="http://chenzhiwei.net/2011/08/shell-io-redirection/">http://chenzhiwei.net/2011/08/shell-io-redirection/</a></p><hr /><div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://chenzhiwei.net/2010/11/shell-script-study-notes-shell/" title="几个简单的shell脚本">几个简单的shell脚本</a></li><li><a href="http://chenzhiwei.net/2010/11/shell-script-study-notes-2/" title="shell 脚本学习之判断条件">shell 脚本学习之判断条件</a></li><li><a href="http://chenzhiwei.net/2010/11/shell-script-study-notes/" title="shell脚本学习">shell脚本学习</a></li><li><a href="http://chenzhiwei.net/2010/10/linux-shell-study-notes-part-5/" title="Linux Shell学习笔记（五）">Linux Shell学习笔记（五）</a></li><li><a href="http://chenzhiwei.net/2010/07/linux-shell-study-notes-part-4/" title="linux shell 学习笔记(四)">linux shell 学习笔记(四)</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://chenzhiwei.net/2011/08/shell-io-redirection/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>一个apache为两个不同端口的网站提供服务</title>
		<link>http://chenzhiwei.net/2011/07/one-apache-hosts-two-site-with-different-port/</link>
		<comments>http://chenzhiwei.net/2011/07/one-apache-hosts-two-site-with-different-port/#comments</comments>
		<pubDate>Wed, 13 Jul 2011 14:52:39 +0000</pubDate>
		<dc:creator>zhiwei</dc:creator>
				<category><![CDATA[软件应用]]></category>
		<category><![CDATA[apache]]></category>
		<category><![CDATA[Linux]]></category>

		<guid isPermaLink="false">http://chenzhiwei.net/?p=30431</guid>
		<description><![CDATA[一个apache开启两个主进程，两个配置文件，服务两个不同端口的网站。 有以下需求： 1. 机器上只安装一个apache。 2. 机器上要放置两个网站，一个端口为80，允许外网访问；另一个网站端口为8080，只允许内网访问。 实现方法： 1. 写两个配置文件httpd1.conf和httpd2.conf。 2. 两个配置文件中除了监听的端口、DocumentRoot和PidFile路径不同外其他地方均可相同（根据自己需求适当修改）。 3. 分别使用以下命令启动或关闭： /usr/sbin/httpd -f /etc/httpd/httpd1.conf -k start&#124;stop&#124;restart /usr/sbin/httpd -f /etc/httpd/httpd2.conf -k start&#124;stop&#124;restart 另外：/usr/sbin/httpd -k restart 命令只会导致子进程（apache用户进程）重新启动，而主进程（root用户）是不会重新启动的。 &#169; 2011, chenzhiwei.net. 版权所有. 本文永久链接：http://chenzhiwei.net/2011/07/one-apache-hosts-two-site-with-different-port/相关日志Shell I/O重定向haproxy是个什么东西安装并配置subversion服务Linux下的NFS,VSFTP,Samba的简单配置海明码详解]]></description>
			<content:encoded><![CDATA[<p>一个apache开启两个主进程，两个配置文件，服务两个不同端口的网站。</p>
<p><strong>有以下需求：</strong></p>
<p>1. 机器上只安装一个apache。</p>
<p>2. 机器上要放置两个网站，一个端口为80，允许外网访问；另一个网站端口为8080，只允许内网访问。<span id="more-30431"></span></p>
<p><strong>实现方法：</strong></p>
<p>1. 写两个配置文件httpd1.conf和httpd2.conf。</p>
<p>2. 两个配置文件中除了监听的端口、DocumentRoot和PidFile路径不同外其他地方均可相同（根据自己需求适当修改）。</p>
<p>3. 分别使用以下命令启动或关闭：</p>
<p>/usr/sbin/httpd -f /etc/httpd/httpd1.conf -k start|stop|restart<br />
/usr/sbin/httpd -f /etc/httpd/httpd2.conf -k start|stop|restart</p>
<p>另外：/usr/sbin/httpd -k restart 命令只会导致子进程（apache用户进程）重新启动，而主进程（root用户）是不会重新启动的。</p>
<p style="font-weight: bold;">&copy; 2011, <a href="http://chenzhiwei.net">chenzhiwei.net</a>. 版权所有.  <br />本文永久链接：<a title="一个apache为两个不同端口的网站提供服务" href="http://chenzhiwei.net/2011/07/one-apache-hosts-two-site-with-different-port/">http://chenzhiwei.net/2011/07/one-apache-hosts-two-site-with-different-port/</a></p><hr /><div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://chenzhiwei.net/2011/08/shell-io-redirection/" title="Shell I/O重定向">Shell I/O重定向</a></li><li><a href="http://chenzhiwei.net/2011/05/what-is-haproxy/" title="haproxy是个什么东西">haproxy是个什么东西</a></li><li><a href="http://chenzhiwei.net/2011/04/install-and-config-svn/" title="安装并配置subversion服务">安装并配置subversion服务</a></li><li><a href="http://chenzhiwei.net/2011/03/linux-nfs-vsftp-samba/" title="Linux下的NFS,VSFTP,Samba的简单配置">Linux下的NFS,VSFTP,Samba的简单配置</a></li><li><a href="http://chenzhiwei.net/2010/12/detailed-explanation-of-hamming-code/" title="海明码详解">海明码详解</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://chenzhiwei.net/2011/07/one-apache-hosts-two-site-with-different-port/feed/</wfw:commentRss>
		<slash:comments>3</slash:comments>
		</item>
		<item>
		<title>haproxy是个什么东西</title>
		<link>http://chenzhiwei.net/2011/05/what-is-haproxy/</link>
		<comments>http://chenzhiwei.net/2011/05/what-is-haproxy/#comments</comments>
		<pubDate>Wed, 25 May 2011 09:59:52 +0000</pubDate>
		<dc:creator>zhiwei</dc:creator>
				<category><![CDATA[编程相关]]></category>
		<category><![CDATA[haproxy]]></category>
		<category><![CDATA[Linux]]></category>
		<category><![CDATA[集群]]></category>

		<guid isPermaLink="false">http://chenzhiwei.net/?p=30427</guid>
		<description><![CDATA[haproxy中的ha意思是高可用性（High Availability），而proxy是代理的意思，合并在一起就是高可用的代理。haproxy在服务器集群中经常会被用到。 Haproxy可以对特定请求进行转发，如：将请求转发到不同机器、将不同的请求转发到不同的机器（图片请求、文本请求、FTP、HTTP请求）、将对特定端口的请求转发到不同机器或另一端口等。 举个例子，一个网站的代码在服务器A上，附件在服务器B上，数据库在服务器C上。我们可以将该网站的所有请求都指向haproxy，haproxy会对请求加以判断，然后将不同的请求转发给不同的服务器。如，将对网页的访问请求转发到服务器A上；对网站附件的请求转发到服务器B上；对网站数据库的请求转发到服务器C上。一般这些服务器都有两组，主（master）服务器和从（slave）服务器。 Haproxy可以与stunnel一起使用来进行443端口的监听，即接收https请求。具体配置方法haproxy的文档上写的很清楚。 &#169; 2011, chenzhiwei.net. 版权所有. 本文永久链接：http://chenzhiwei.net/2011/05/what-is-haproxy/相关日志Shell I/O重定向一个apache为两个不同端口的网站提供服务Linux下的NFS,VSFTP,Samba的简单配置海明码详解Linux内核基本结构]]></description>
			<content:encoded><![CDATA[<p>haproxy中的ha意思是高可用性（High Availability），而proxy是代理的意思，合并在一起就是高可用的代理。haproxy在服务器集群中经常会被用到。<span id="more-30427"></span></p>
<div>Haproxy可以对特定请求进行转发，如：将请求转发到不同机器、将不同的请求转发到不同的机器（图片请求、文本请求、FTP、HTTP请求）、将对特定端口的请求转发到不同机器或另一端口等。</div>
<div></div>
<div>举个例子，一个网站的代码在服务器A上，附件在服务器B上，数据库在服务器C上。我们可以将该网站的所有请求都指向haproxy，haproxy会对请求加以判断，然后将不同的请求转发给不同的服务器。如，将对网页的访问请求转发到服务器A上；对网站附件的请求转发到服务器B上；对网站数据库的请求转发到服务器C上。一般这些服务器都有两组，主（master）服务器和从（slave）服务器。</div>
<div></div>
<div>Haproxy可以与stunnel一起使用来进行443端口的监听，即接收https请求。具体配置方法haproxy的文档上写的很清楚。</div>
<p style="font-weight: bold;">&copy; 2011, <a href="http://chenzhiwei.net">chenzhiwei.net</a>. 版权所有.  <br />本文永久链接：<a title="haproxy是个什么东西" href="http://chenzhiwei.net/2011/05/what-is-haproxy/">http://chenzhiwei.net/2011/05/what-is-haproxy/</a></p><hr /><div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://chenzhiwei.net/2011/08/shell-io-redirection/" title="Shell I/O重定向">Shell I/O重定向</a></li><li><a href="http://chenzhiwei.net/2011/07/one-apache-hosts-two-site-with-different-port/" title="一个apache为两个不同端口的网站提供服务">一个apache为两个不同端口的网站提供服务</a></li><li><a href="http://chenzhiwei.net/2011/03/linux-nfs-vsftp-samba/" title="Linux下的NFS,VSFTP,Samba的简单配置">Linux下的NFS,VSFTP,Samba的简单配置</a></li><li><a href="http://chenzhiwei.net/2010/12/detailed-explanation-of-hamming-code/" title="海明码详解">海明码详解</a></li><li><a href="http://chenzhiwei.net/2010/12/the-basic-structure-of-linux-kernel/" title="Linux内核基本结构">Linux内核基本结构</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://chenzhiwei.net/2011/05/what-is-haproxy/feed/</wfw:commentRss>
		<slash:comments>4</slash:comments>
		</item>
		<item>
		<title>Linux下的NFS,VSFTP,Samba的简单配置</title>
		<link>http://chenzhiwei.net/2011/03/linux-nfs-vsftp-samba/</link>
		<comments>http://chenzhiwei.net/2011/03/linux-nfs-vsftp-samba/#comments</comments>
		<pubDate>Tue, 29 Mar 2011 05:22:45 +0000</pubDate>
		<dc:creator>zhiwei</dc:creator>
				<category><![CDATA[编程相关]]></category>
		<category><![CDATA[Linux]]></category>
		<category><![CDATA[nfs]]></category>
		<category><![CDATA[samba]]></category>
		<category><![CDATA[vsftp]]></category>

		<guid isPermaLink="false">http://chenzhiwei.net/?p=30424</guid>
		<description><![CDATA[从网上搜集的，自己整理了一下，又亲自测试验证了正确性。 地址是：http://goo.gl/tXyOc &#169; 2011, chenzhiwei.net. 版权所有. 本文永久链接：http://chenzhiwei.net/2011/03/linux-nfs-vsftp-samba/相关日志Shell I/O重定向一个apache为两个不同端口的网站提供服务haproxy是个什么东西海明码详解Linux内核基本结构]]></description>
			<content:encoded><![CDATA[<p>从网上搜集的，自己整理了一下，又亲自测试验证了正确性。</p>
<p>地址是：<a href="http://goo.gl/tXyOc" target="_blank">http://goo.gl/tXyOc</a></p>
<p style="font-weight: bold;">&copy; 2011, <a href="http://chenzhiwei.net">chenzhiwei.net</a>. 版权所有.  <br />本文永久链接：<a title="Linux下的NFS,VSFTP,Samba的简单配置" href="http://chenzhiwei.net/2011/03/linux-nfs-vsftp-samba/">http://chenzhiwei.net/2011/03/linux-nfs-vsftp-samba/</a></p><hr /><div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://chenzhiwei.net/2011/08/shell-io-redirection/" title="Shell I/O重定向">Shell I/O重定向</a></li><li><a href="http://chenzhiwei.net/2011/07/one-apache-hosts-two-site-with-different-port/" title="一个apache为两个不同端口的网站提供服务">一个apache为两个不同端口的网站提供服务</a></li><li><a href="http://chenzhiwei.net/2011/05/what-is-haproxy/" title="haproxy是个什么东西">haproxy是个什么东西</a></li><li><a href="http://chenzhiwei.net/2010/12/detailed-explanation-of-hamming-code/" title="海明码详解">海明码详解</a></li><li><a href="http://chenzhiwei.net/2010/12/the-basic-structure-of-linux-kernel/" title="Linux内核基本结构">Linux内核基本结构</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://chenzhiwei.net/2011/03/linux-nfs-vsftp-samba/feed/</wfw:commentRss>
		<slash:comments>6</slash:comments>
		</item>
		<item>
		<title>海明码详解</title>
		<link>http://chenzhiwei.net/2010/12/detailed-explanation-of-hamming-code/</link>
		<comments>http://chenzhiwei.net/2010/12/detailed-explanation-of-hamming-code/#comments</comments>
		<pubDate>Sat, 18 Dec 2010 05:42:44 +0000</pubDate>
		<dc:creator>zhiwei</dc:creator>
				<category><![CDATA[编程相关]]></category>
		<category><![CDATA[Linux]]></category>
		<category><![CDATA[海明码]]></category>

		<guid isPermaLink="false">http://chenzhiwei.net/?p=30409</guid>
		<description><![CDATA[海明码是奇偶校验的一种扩充。它采用多位校验码的方式，在这些校验位中的每一位都对不同的信息数据位进行奇偶校验，通过合理地安排每个校验位对原始数据进行校验位组合，可以达到发现错误，纠正错误的目的。 奇偶校验是一种校验代码传输正确性的方法。根据被传输的一组二进制代码的数位中“1”的个数是奇数或偶数来进行校验。采用奇数的称为奇校验，反之，称为偶校验。采用何种校验是事先规定好的。通常专门设置一个奇偶校验位，用它使这组代码中“1”的个数为奇数或偶数。若用奇校验，则当接收端收到这组代码时，校验“1”的个数是否为奇数，从而确定传输代码的正确性。 注：奇偶较验只能知道数据在传输过程中有没有出错，而不能发现具体是哪位出错。海明码可以发现出数据在传输过程中哪一位出错。但有一点必须明白，奇偶较验和海明码较验都是只能较验一位出错的情况。 假设数据位有m位，如何设定校验位k的长度才能满足纠正一位错误的要求呢?我们这里做一个简单的推导。k位的校验码可以有2^k个值。显然，其中一个值表示数据是正确的，而剩下的2^k –1个值意味着数据中存在错误，如果能够满足： 2^k–1&#62;=m + k (m + k为编码后的总长度)，在理论上k个校验码就可以判断是哪一位(包括信息码和校验码)出现问题。 需要注意的是：数据有m位，较验码有k位，合起来也是就信息码，共有m+k位，并且只能有1位在传输中出错，那么这个m+k位的信息码出错的可能性就有m+k种（第1位出错，第2位出错，第3位出错，&#8230;第m位出错&#8230;第m+k位出错）。较验码有k位，那么这k位较验码有2^k个组合（0000&#8230;-1111&#8230;），这2^k个组合对应着m+k种出错和1种不出错，所以k应该满足2^k-1&#62;m+k，只有这样才能让k位较验码来校验这m+k位数据是否会出错。 更详细的介绍来看这里：https://docs.google.com/View?id=dhjhtxtq_1f8nkhbdh &#169; 2010, chenzhiwei.net. 版权所有. 本文永久链接：http://chenzhiwei.net/2010/12/detailed-explanation-of-hamming-code/相关日志Shell I/O重定向一个apache为两个不同端口的网站提供服务haproxy是个什么东西Linux下的NFS,VSFTP,Samba的简单配置Linux内核基本结构]]></description>
			<content:encoded><![CDATA[<p>海明码是奇偶校验的一种扩充。它采用多位校验码的方式，在这些校验位中的每一位都对不同的信息数据位进行奇偶校验，通过合理地安排每个校验位对原始数据进行校验位组合，可以达到发现错误，纠正错误的目的。<span id="more-30409"></span></p>
<p>奇偶校验是一种校验代码传输正确性的方法。根据被传输的一组二进制代码的数位中“1”的个数是奇数或偶数来进行校验。采用奇数的称为奇校验，反之，称为偶校验。采用何种校验是事先规定好的。通常专门设置一个奇偶校验位，用它使这组代码中“1”的个数为奇数或偶数。若用奇校验，则当接收端收到这组代码时，校验“1”的个数是否为奇数，从而确定传输代码的正确性。</p>
<p>注：奇偶较验只能知道数据在传输过程中有没有出错，而不能发现具体是哪位出错。海明码可以发现出数据在传输过程中哪一位出错。但有一点必须明白，奇偶较验和海明码较验都是只能较验一位出错的情况。</p>
<p>假设数据位有m位，如何设定校验位k的长度才能满足纠正一位错误的要求呢?我们这里做一个简单的推导。k位的校验码可以有2^k个值。显然，其中一个值表示数据是正确的，而剩下的2^k –1个值意味着数据中存在错误，如果能够满足： 2^k–1&gt;=m + k (m + k为编码后的总长度)，在理论上k个校验码就可以判断是哪一位(包括信息码和校验码)出现问题。</p>
<p><strong>需要注意的是：</strong>数据有m位，较验码有k位，合起来也是就信息码，共有m+k位，并且只能有1位在传输中出错，那么这个m+k位的信息码出错的可能性就有m+k种（第1位出错，第2位出错，第3位出错，&#8230;第m位出错&#8230;第m+k位出错）。较验码有k位，那么这k位较验码有2^k个组合（0000&#8230;-1111&#8230;），这2^k个组合对应着m+k种出错和1种不出错，所以k应该满足2^k-1&gt;m+k，只有这样才能让k位较验码来校验这m+k位数据是否会出错。</p>
<p>更详细的介绍来看这里：<a href="https://docs.google.com/View?id=dhjhtxtq_1f8nkhbdh" target="_blank">https://docs.google.com/View?id=dhjhtxtq_1f8nkhbdh</a></p>
<p style="font-weight: bold;">&copy; 2010, <a href="http://chenzhiwei.net">chenzhiwei.net</a>. 版权所有.  <br />本文永久链接：<a title="海明码详解" href="http://chenzhiwei.net/2010/12/detailed-explanation-of-hamming-code/">http://chenzhiwei.net/2010/12/detailed-explanation-of-hamming-code/</a></p><hr /><div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://chenzhiwei.net/2011/08/shell-io-redirection/" title="Shell I/O重定向">Shell I/O重定向</a></li><li><a href="http://chenzhiwei.net/2011/07/one-apache-hosts-two-site-with-different-port/" title="一个apache为两个不同端口的网站提供服务">一个apache为两个不同端口的网站提供服务</a></li><li><a href="http://chenzhiwei.net/2011/05/what-is-haproxy/" title="haproxy是个什么东西">haproxy是个什么东西</a></li><li><a href="http://chenzhiwei.net/2011/03/linux-nfs-vsftp-samba/" title="Linux下的NFS,VSFTP,Samba的简单配置">Linux下的NFS,VSFTP,Samba的简单配置</a></li><li><a href="http://chenzhiwei.net/2010/12/the-basic-structure-of-linux-kernel/" title="Linux内核基本结构">Linux内核基本结构</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://chenzhiwei.net/2010/12/detailed-explanation-of-hamming-code/feed/</wfw:commentRss>
		<slash:comments>12</slash:comments>
		</item>
		<item>
		<title>Linux内核基本结构</title>
		<link>http://chenzhiwei.net/2010/12/the-basic-structure-of-linux-kernel/</link>
		<comments>http://chenzhiwei.net/2010/12/the-basic-structure-of-linux-kernel/#comments</comments>
		<pubDate>Sat, 11 Dec 2010 06:30:21 +0000</pubDate>
		<dc:creator>zhiwei</dc:creator>
				<category><![CDATA[搜索引擎]]></category>
		<category><![CDATA[kernel]]></category>
		<category><![CDATA[Linux]]></category>
		<category><![CDATA[OS]]></category>

		<guid isPermaLink="false">http://chenzhiwei.net/?p=30406</guid>
		<description><![CDATA[Linux内核是Linux操作系统的核心，它负责管理系统的进程、内存、设备驱动程序、文件和网络系统，决定着系统的性能和稳定性。Linux的一个重要的特点就是其源代码的公开性，所有的内核源程序都可以在/usr/src/linux目录下找到，大部分应用软件也都是遵循GPL而设计的。 Linux核心源程序通常都安装在/usr/src/linux目录下，都是一个稳定地发行的核心，而任何奇数核心源程序的文件按树形结构进行组织，在源程序树的最上层。目录/usr/src/linux下有这样一些目录和文件。 1. COPYING：GPL版权声明。对具有GPL版权的源代码改动而形成的程序，或使用GPL工具产生的程序，具有使用GPL发表的义务，如公开源代码。 2. CREDITS：光荣榜。对Linux做出过很大贡献的一些人的信息。 3. MAINTAINERS：维护人员列表，当前版本的内核各部分都由谁负责。 4. Makefile：用来组织内核的各模块，记录了模块间的相互联系和依托关系，编译时使用；仔细阅读各子目录下的Makefile文件对弄清各文件之间的联系和依托关系很有帮助。 5. README：核心及其编译配置方法的简单介绍。 6. Rules.make：各种Makefile文件的make程序所使用的一些共同规则。 7. REPORTING-BUGS：有关报告Bug的一些内容。 8. arch/：arch子目录包括了所有和体系结构相关的核心代码。它的每一个子目录都代表一种支持的体系结构，例如i386就是关于Intel CPU及与之相兼容体系结构的子目录。PC一般都基于此目录，在2.6版本以后，增加了arm目录。 9. include/：include子目录包括编译核心所需要的大部分头文件。与平台无关的头文件在include/linux子目录下，与Intel CPU相关的头文件在include/asm-i386子目录下，而include/scsi目录则是有关SCSI设备的头文件目录。 10. init/：这个目录包含核心的初始化代码（注：不是系统的引导代码），包含两个文件main.c和Version.c，是研究核心如何工作的好的起点之一。 11. mm/：这个目录包括所有独立于CPU体系结构的内存管理代码，如页式存储管理内存的分配和释放等；而和体系结构相关的内存管理代码则位于arch/*/mm/目录下，例如 arch/i386/mm/Fault.c。 12. kernel/：主要的核心代码，此目录下的文件实现了大多数Linux系统的内核函数，其中最重要的文件当属sched.c；同样，和体系结构相关的代码则位于 arch/*/kernel中。 13. drivers/：放置系统所有的设备驱动程序；每种驱动程序又各占用一个子目录，如/block下为块设备驱动程序，比如ide（ide.c）。如果希望查看所有可能包含文件系统的设备是如何初始化的，可以查看drivers/block/genhd.c中的device_setup()。它不仅初始化硬盘，也初始化网络，因为安装NFS文件系统的时候需要网络。 14. Documentation/：文档目录，没有内核代码，只是一套有用的文档。 15. fs/：所有的文件系统代码和各种类型的文件操作代码，它的每一个子目录支持一个文件系统，例如fat和ext。 16. ipc/：这个目录包含核心的进程间通信的代码。 17. lib/：放置核心的库代码。 18. net/：核心与网络相关的代码。 19. modules/：模块文件目录，是个空目录，用于存放编译时产生的模块目标文件。 20. scripts/：描述文件、脚本，用于对核心的配置 另外，在每个目录下一般都有一个Makefile和README文件。不同的Linux发行版的内核代码也有微小差别，以上是大部分Linux系统的内核代码目录文件。 &#169; 2010, chenzhiwei.net. 版权所有. 本文永久链接：http://chenzhiwei.net/2010/12/the-basic-structure-of-linux-kernel/相关日志Linux内核代码中的Makefile文件Linux内核体系结构windows下硬盘安装ubuntu的方法Shell I/O重定向一个apache为两个不同端口的网站提供服务]]></description>
			<content:encoded><![CDATA[<p>Linux内核是Linux操作系统的核心，它负责管理系统的进程、内存、设备驱动程序、文件和网络系统，决定着系统的性能和稳定性。Linux的一个重要的特点就是其源代码的公开性，所有的内核源程序都可以在/usr/src/linux目录下找到，大部分应用软件也都是遵循GPL而设计的。<span id="more-30406"></span></p>
<p>Linux核心源程序通常都安装在/usr/src/linux目录下，都是一个稳定地发行的核心，而任何奇数核心源程序的文件按树形结构进行组织，在源程序树的最上层。目录/usr/src/linux下有这样一些目录和文件。</p>
<p>1. COPYING：GPL版权声明。对具有GPL版权的源代码改动而形成的程序，或使用GPL工具产生的程序，具有使用GPL发表的义务，如公开源代码。</p>
<p>2. CREDITS：光荣榜。对Linux做出过很大贡献的一些人的信息。</p>
<p>3. MAINTAINERS：维护人员列表，当前版本的内核各部分都由谁负责。</p>
<p>4. Makefile：用来组织内核的各模块，记录了模块间的相互联系和依托关系，编译时使用；仔细阅读各子目录下的Makefile文件对弄清各文件之间的联系和依托关系很有帮助。</p>
<p>5. README：核心及其编译配置方法的简单介绍。</p>
<p>6. Rules.make：各种Makefile文件的make程序所使用的一些共同规则。</p>
<p>7. REPORTING-BUGS：有关报告Bug的一些内容。</p>
<p>8. arch/：arch子目录包括了所有和体系结构相关的核心代码。它的每一个子目录都代表一种支持的体系结构，例如i386就是关于Intel CPU及与之相兼容体系结构的子目录。PC一般都基于此目录，在2.6版本以后，增加了arm目录。</p>
<p>9. include/：include子目录包括编译核心所需要的大部分头文件。与平台无关的头文件在include/linux子目录下，与Intel CPU相关的头文件在include/asm-i386子目录下，而include/scsi目录则是有关SCSI设备的头文件目录。</p>
<p>10. init/：这个目录包含核心的初始化代码（注：不是系统的引导代码），包含两个文件main.c和Version.c，是研究核心如何工作的好的起点之一。</p>
<p>11. mm/：这个目录包括所有独立于CPU体系结构的内存管理代码，如页式存储管理内存的分配和释放等；而和体系结构相关的内存管理代码则位于arch/*/mm/目录下，例如 arch/i386/mm/Fault.c。</p>
<p>12. kernel/：主要的核心代码，此目录下的文件实现了大多数Linux系统的内核函数，其中最重要的文件当属sched.c；同样，和体系结构相关的代码则位于 arch/*/kernel中。</p>
<p>13. drivers/：放置系统所有的设备驱动程序；每种驱动程序又各占用一个子目录，如/block下为块设备驱动程序，比如ide（ide.c）。如果希望查看所有可能包含文件系统的设备是如何初始化的，可以查看drivers/block/genhd.c中的device_setup()。它不仅初始化硬盘，也初始化网络，因为安装NFS文件系统的时候需要网络。</p>
<p>14. Documentation/：文档目录，没有内核代码，只是一套有用的文档。</p>
<p>15. fs/：所有的文件系统代码和各种类型的文件操作代码，它的每一个子目录支持一个文件系统，例如fat和ext。</p>
<p>16. ipc/：这个目录包含核心的进程间通信的代码。</p>
<p>17. lib/：放置核心的库代码。</p>
<p>18. net/：核心与网络相关的代码。</p>
<p>19. modules/：模块文件目录，是个空目录，用于存放编译时产生的模块目标文件。</p>
<p>20. scripts/：描述文件、脚本，用于对核心的配置</p>
<p>另外，在每个目录下一般都有一个Makefile和README文件。不同的Linux发行版的内核代码也有微小差别，以上是大部分Linux系统的内核代码目录文件。</p>
<p style="font-weight: bold;">&copy; 2010, <a href="http://chenzhiwei.net">chenzhiwei.net</a>. 版权所有.  <br />本文永久链接：<a title="Linux内核基本结构" href="http://chenzhiwei.net/2010/12/the-basic-structure-of-linux-kernel/">http://chenzhiwei.net/2010/12/the-basic-structure-of-linux-kernel/</a></p><hr /><div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://chenzhiwei.net/2010/12/makefile-in-linux-kernel/" title="Linux内核代码中的Makefile文件">Linux内核代码中的Makefile文件</a></li><li><a href="http://chenzhiwei.net/2010/12/linux-kernel-architecture/" title="Linux内核体系结构">Linux内核体系结构</a></li><li><a href="http://chenzhiwei.net/2010/03/install-ubuntu-under-windows/" title="windows下硬盘安装ubuntu的方法">windows下硬盘安装ubuntu的方法</a></li><li><a href="http://chenzhiwei.net/2011/08/shell-io-redirection/" title="Shell I/O重定向">Shell I/O重定向</a></li><li><a href="http://chenzhiwei.net/2011/07/one-apache-hosts-two-site-with-different-port/" title="一个apache为两个不同端口的网站提供服务">一个apache为两个不同端口的网站提供服务</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://chenzhiwei.net/2010/12/the-basic-structure-of-linux-kernel/feed/</wfw:commentRss>
		<slash:comments>8</slash:comments>
		</item>
		<item>
		<title>Linux内核代码中的Makefile文件</title>
		<link>http://chenzhiwei.net/2010/12/makefile-in-linux-kernel/</link>
		<comments>http://chenzhiwei.net/2010/12/makefile-in-linux-kernel/#comments</comments>
		<pubDate>Sat, 04 Dec 2010 02:01:29 +0000</pubDate>
		<dc:creator>zhiwei</dc:creator>
				<category><![CDATA[搜索引擎]]></category>
		<category><![CDATA[kernel]]></category>
		<category><![CDATA[Linux]]></category>
		<category><![CDATA[OS]]></category>

		<guid isPermaLink="false">http://chenzhiwei.net/?p=30398</guid>
		<description><![CDATA[Makefile文件是make工具程序的信息文件，使用make时需要Makefile文件，Makefile文件定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作。 Makefile文件简介 Makefile文件是make工具程序的配置文件。make工具程序的主要用途是能自动地决定一个含有很多源程序文件的大型程序中哪个文件需要被重新编译。Makefile的使用比较复杂，这里只作简要介绍。 为了使用make程序，用户就需要makefile文件来告诉make要做些什么工作。通常，makefile文件会告诉make如何编译和连接一个文件。当明确指出时，makefile文件还可以告诉make运行各位命令（如，作为清理操作而删除某些文件）。 make的执行过程分为两个不同阶段。在第一阶段，它读取所在的makefile文件以及包含的makefile文件等，记录所在的变更及其值、隐式的或 显式的规则，并构造出所有目标对象及其先决条件的一幅全景图。在第二阶段期间，make就使用这些内部结构来确定哪个目标对象需要被重建，并且使用相应的 规则来操作。 当make重新编译程序时，每个修改过的C语言代码文件必须被重新编译。如果一个头文件被修改过了，那么包含该头文件的文件也必须重新编译以保证生成的目标文件是最近的。Makefile文件有很多规则，这里就不做过多介绍。 Makefile文件功能 Makefile文件相当于程序编译过程中的批处理文件。是工具程序make运行时的输入数据文件。只要含有Makefile的当前目录中键入make命令，它就会依据Makefile文件中的设置对源程序或目标代码文件进行编译、链接或进行安装等活动。 make工具程序有自动地确定一个大程序系统中的哪些程序文件需要被重新编译，并发出命令对这些程序文件进行编译。在使用make之前，需要编写 Makefile信息文件，该文件描述了整个程序包中各程序之间的关系，并针对每个需要更新的文件给出具体的控制命令。通常，执行程序根据其目标文件进行 更新的，而这些上档文件则是由编译程序创建的。一旦编写好一个合适的Makefile文件，那么在你每次修改过程序系统中的某些源代码文件后，执行 make命令就能进行所有必要的重新编译工作。make程序是使用Makefile数据文件和代码文件的最后修改时间（last- modification time）来确定哪些文件需要进行更新，对于每一个需要更新的文件它会根据Makefile中的信息发出相应的命令。在Makefile文件中，开头为 “#”的行是注释行。 Linux内核源码中的Makefile文件 Linux内核源码中的Makefile文件的主要功能是指示make程序最终使用独立编译连接成的tools/目录中的build执行程序将所有内核编 译代码连接和合并成一个可运行的内核映像文件image。具体是对boot/bootsect.s、boot/setup.s使用8086汇编器进行编 译，分别生成各自的执行模块。再对源代码中的其他所有程序使用GNU的编译器gcc/gas进行编译并连接成模块system，再用build工具将这三 块组合成一个内核映像文件image。 注：节选自《Linux内核完全注释》，有改动。 &#169; 2010, chenzhiwei.net. 版权所有. 本文永久链接：http://chenzhiwei.net/2010/12/makefile-in-linux-kernel/相关日志Linux内核基本结构Linux内核体系结构windows下硬盘安装ubuntu的方法Shell I/O重定向一个apache为两个不同端口的网站提供服务]]></description>
			<content:encoded><![CDATA[<p>Makefile文件是make工具程序的信息文件，使用make时需要Makefile文件，Makefile文件定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作。<span id="more-30398"></span></p>
<p><strong>Makefile文件简介</strong></p>
<p>Makefile文件是make工具程序的配置文件。make工具程序的主要用途是能自动地决定一个含有很多源程序文件的大型程序中哪个文件需要被重新编译。Makefile的使用比较复杂，这里只作简要介绍。</p>
<p>为了使用make程序，用户就需要makefile文件来告诉make要做些什么工作。通常，makefile文件会告诉make如何编译和连接一个文件。当明确指出时，makefile文件还可以告诉make运行各位命令（如，作为清理操作而删除某些文件）。</p>
<p>make的执行过程分为两个不同阶段。在第一阶段，它读取所在的makefile文件以及包含的makefile文件等，记录所在的变更及其值、隐式的或 显式的规则，并构造出所有目标对象及其先决条件的一幅全景图。在第二阶段期间，make就使用这些内部结构来确定哪个目标对象需要被重建，并且使用相应的 规则来操作。</p>
<p>当make重新编译程序时，每个修改过的C语言代码文件必须被重新编译。如果一个头文件被修改过了，那么包含该头文件的文件也必须重新编译以保证生成的目标文件是最近的。Makefile文件有很多规则，这里就不做过多介绍。</p>
<p><strong>Makefile文件功能</strong></p>
<p>Makefile文件相当于程序编译过程中的批处理文件。是工具程序make运行时的输入数据文件。只要含有Makefile的当前目录中键入make命令，它就会依据Makefile文件中的设置对源程序或目标代码文件进行编译、链接或进行安装等活动。</p>
<p>make工具程序有自动地确定一个大程序系统中的哪些程序文件需要被重新编译，并发出命令对这些程序文件进行编译。在使用make之前，需要编写 Makefile信息文件，该文件描述了整个程序包中各程序之间的关系，并针对每个需要更新的文件给出具体的控制命令。通常，执行程序根据其目标文件进行 更新的，而这些上档文件则是由编译程序创建的。一旦编写好一个合适的Makefile文件，那么在你每次修改过程序系统中的某些源代码文件后，执行 make命令就能进行所有必要的重新编译工作。make程序是使用Makefile数据文件和代码文件的最后修改时间（last- modification  time）来确定哪些文件需要进行更新，对于每一个需要更新的文件它会根据Makefile中的信息发出相应的命令。在Makefile文件中，开头为 “#”的行是注释行。</p>
<p><strong>Linux内核源码中的Makefile文件</strong></p>
<p><img class="alignnone" title="linux内核代码结构" src="http://farm6.static.flickr.com/5008/5229953483_1df1a4050b_z.jpg" alt="" width="580" height="325" /></p>
<p>Linux内核源码中的Makefile文件的主要功能是指示make程序最终使用独立编译连接成的tools/目录中的build执行程序将所有内核编 译代码连接和合并成一个可运行的内核映像文件image。具体是对boot/bootsect.s、boot/setup.s使用8086汇编器进行编 译，分别生成各自的执行模块。再对源代码中的其他所有程序使用GNU的编译器gcc/gas进行编译并连接成模块system，再用build工具将这三 块组合成一个内核映像文件image。</p>
<p><img class="alignnone" title="linux内核编译连接结构" src="http://farm6.static.flickr.com/5164/5230546336_09eb9ecd8d_z.jpg" alt="" width="580" height="315" /></p>
<p>注：节选自《Linux内核完全注释》，有改动。</p>
<p style="font-weight: bold;">&copy; 2010, <a href="http://chenzhiwei.net">chenzhiwei.net</a>. 版权所有.  <br />本文永久链接：<a title="Linux内核代码中的Makefile文件" href="http://chenzhiwei.net/2010/12/makefile-in-linux-kernel/">http://chenzhiwei.net/2010/12/makefile-in-linux-kernel/</a></p><hr /><div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://chenzhiwei.net/2010/12/the-basic-structure-of-linux-kernel/" title="Linux内核基本结构">Linux内核基本结构</a></li><li><a href="http://chenzhiwei.net/2010/12/linux-kernel-architecture/" title="Linux内核体系结构">Linux内核体系结构</a></li><li><a href="http://chenzhiwei.net/2010/03/install-ubuntu-under-windows/" title="windows下硬盘安装ubuntu的方法">windows下硬盘安装ubuntu的方法</a></li><li><a href="http://chenzhiwei.net/2011/08/shell-io-redirection/" title="Shell I/O重定向">Shell I/O重定向</a></li><li><a href="http://chenzhiwei.net/2011/07/one-apache-hosts-two-site-with-different-port/" title="一个apache为两个不同端口的网站提供服务">一个apache为两个不同端口的网站提供服务</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://chenzhiwei.net/2010/12/makefile-in-linux-kernel/feed/</wfw:commentRss>
		<slash:comments>5</slash:comments>
		</item>
		<item>
		<title>Linux内核体系结构</title>
		<link>http://chenzhiwei.net/2010/12/linux-kernel-architecture/</link>
		<comments>http://chenzhiwei.net/2010/12/linux-kernel-architecture/#comments</comments>
		<pubDate>Wed, 01 Dec 2010 09:00:19 +0000</pubDate>
		<dc:creator>zhiwei</dc:creator>
				<category><![CDATA[搜索引擎]]></category>
		<category><![CDATA[编程相关]]></category>
		<category><![CDATA[kernel]]></category>
		<category><![CDATA[Linux]]></category>
		<category><![CDATA[OS]]></category>

		<guid isPermaLink="false">http://chenzhiwei.net/?p=30396</guid>
		<description><![CDATA[Linux内核的主要用途就是为了与计算机硬件进行交互，实现对硬件部件的编程控制和接口操作，调度对硬件资源的访问，并为计算机上用户程序提供一个高级的执行环境和对硬件的虚拟接口。 Linux内核模式 操作系统内核的结构模式主要可分为整体式的单内核模式和层次式的微内核模式。而Linux内核使用的则是单内核模式，其内核代码结构紧凑、执行速度快，但是层次性不强。 单内核模式的系统所提供的服务流程为：应用程序使用指定的参数值执行系统调用指令（int x80），使用CPU从用户态（User Mode）切换到核心态（Kernel Mode），然后操作系统根据具体的参数值调用服务程序，而这些服务程序则根据需要再调用底层的一些支持函数以完成特定的功能。在完成了应用程序所要求的服务后，操作系统切换到用户态，返回到应用程序中继续执行后面的命令。概要地讲，单内核模式的内核可以粗略地分为三个层次：调用服务的主程序层、执行系统调用的服务层和支持系统调用的底层函数。 Linux内核的模块 Linux内核主要由5个模块构成，它们分别是：进程调度模块、内存管理模块、文件系统模块、进程间通信模块和网络接口模块。进程调度模块用来负责控制进程对CPU资源的使用，所采取的调度策略是各进程能够公开合理地访问CPU，同时保证内核及时地执行硬件操作。内存管理模块用于确保所有进程能够安全地共享机器主内存区，同时，内存管理模块还支持虚拟内存管理方式，使得Linux支持进程使用比实际内存空间更多的内存容量。文件系统模块用于支持对外部设备的驱动和存储。虚拟文件系统模块通过向所有的外部存储设备提供一个通用的文件接口，隐藏了各种硬件设备的不同细节。从而提供并支持与其他操作系统兼容的多种文件系统格式。进程间通信模块子系统用于支持多种进程间的信息交换方式。内核接口模块提供对多种网络通信标准的访问并支持许多网络硬件。 Linux内核进程控制 程序是一个可执行的文件，而进程（process）是一个执行中的程序实例。在Linux操作系统上同时可以执行多个进程。内核程序使用进程标识号（process ID,pid）来标识每个进程。进程由可执行的指令代码、数据和堆栈区组成。进程中的代码和数据部分分别对应一个执行文件中的代码段、数据段。每个进程只能执行自己的代码和访问自己的数据及堆栈区。进程之间相互通信需要通过系统调用来进行。 Linux系统中，一个进程可以在内核态（Kernel Mode）或用户态（UserMode）下执行，因此，linux内核栈和用户栈是分开的。用户栈用于进程在用户态下临时保存调用函数的参数、局部变量等数据。内核栈则含有内核程序执行函数调用时的信息。 当进程正在被CPU执行时，被称为处于执行状态（running）。当进程正在等待系统中的资源而处于等待状态时，则称其处于睡眠等待状态。在Linux系统中，可分为可中断的和不可中断的等待状态。当系统资源已经可用时，进程就被唤醒而进入准备运行状态，该状态称为就绪状态。当进程已经停止运行，但其父进程还没有询问其状态时，则称该进程处于僵死状态。当进程被终止时，称其处于停止状态。 只有当进程从“内核运行态”转移到“睡眠状态”时，内核才会进行进程切换操作。在内核态下运行的进程不能被其他进程抢占，而且一个进程不能改变另一个进程的状态。为了避免进程切换时造成内核数据错误，内核在执行临界区代码时会禁止一切中断。 Linux内核对内存的使用方法 为了有效地使用系统的物理内存，内存被划分成几个功能区域 其中，linux内核程序占据物理内存的开始部分，接下来是用供硬盘或软盘等块设备使用的高速缓冲区部分。当一个进程需要读取块设备中的数据时，系统会首先将数据读到高速缓冲区中；当有数据需要写到块设备上去时，系统也是先将数据放到调整缓冲区中，然后由块设备驱动程序写到设备上。最后部分是供所有程序可以随时申请使用的主内存部分。内核程序在使用主内存区时，也同样要首先向内核的内存管理模块提出申请，在申请成功后方能使用。对于含有RAM虚拟盘的系统，主内存区头部还要划去一部分，供虚拟盘存放数据。 注：节选自《linux内核完全注释》，有改动。 &#169; 2010, chenzhiwei.net. 版权所有. 本文永久链接：http://chenzhiwei.net/2010/12/linux-kernel-architecture/相关日志Linux内核基本结构Linux内核代码中的Makefile文件windows下硬盘安装ubuntu的方法Shell I/O重定向一个apache为两个不同端口的网站提供服务]]></description>
			<content:encoded><![CDATA[<p>Linux内核的主要用途就是为了与计算机硬件进行交互，实现对硬件部件的编程控制和接口操作，调度对硬件资源的访问，并为计算机上用户程序提供一个高级的执行环境和对硬件的虚拟接口。<span id="more-30396"></span></p>
<p><strong>Linux内核模式</strong></p>
<p>操作系统内核的结构模式主要可分为整体式的单内核模式和层次式的微内核模式。而Linux内核使用的则是单内核模式，其内核代码结构紧凑、执行速度快，但是层次性不强。</p>
<p>单内核模式的系统所提供的服务流程为：应用程序使用指定的参数值执行系统调用指令（int x80），使用CPU从用户态（User Mode）切换到核心态（Kernel Mode），然后操作系统根据具体的参数值调用服务程序，而这些服务程序则根据需要再调用底层的一些支持函数以完成特定的功能。在完成了应用程序所要求的服务后，操作系统切换到用户态，返回到应用程序中继续执行后面的命令。概要地讲，单内核模式的内核可以粗略地分为三个层次：调用服务的主程序层、执行系统调用的服务层和支持系统调用的底层函数。</p>
<p><strong>Linux内核的模块</strong></p>
<p>Linux内核主要由5个模块构成，它们分别是：进程调度模块、内存管理模块、文件系统模块、进程间通信模块和网络接口模块。进程调度模块用来负责控制进程对CPU资源的使用，所采取的调度策略是各进程能够公开合理地访问CPU，同时保证内核及时地执行硬件操作。内存管理模块用于确保所有进程能够安全地共享机器主内存区，同时，内存管理模块还支持虚拟内存管理方式，使得Linux支持进程使用比实际内存空间更多的内存容量。文件系统模块用于支持对外部设备的驱动和存储。虚拟文件系统模块通过向所有的外部存储设备提供一个通用的文件接口，隐藏了各种硬件设备的不同细节。从而提供并支持与其他操作系统兼容的多种文件系统格式。进程间通信模块子系统用于支持多种进程间的信息交换方式。内核接口模块提供对多种网络通信标准的访问并支持许多网络硬件。</p>
<div class="mceTemp">
<dl class="wp-caption alignnone" style="width: 587px;">
<dt class="wp-caption-dt"><img title="Linux内核系统模块结构及相互依赖关系" src="http://farm6.static.flickr.com/5248/5222725373_3ab556a42a_z.jpg" alt="" width="577" height="282" /></dt>
</dl>
</div>
<p><strong>Linux内核进程控制</strong></p>
<p>程序是一个可执行的文件，而进程（process）是一个执行中的程序实例。在Linux操作系统上同时可以执行多个进程。内核程序使用进程标识号（process ID,pid）来标识每个进程。进程由可执行的指令代码、数据和堆栈区组成。进程中的代码和数据部分分别对应一个执行文件中的代码段、数据段。每个进程只能执行自己的代码和访问自己的数据及堆栈区。进程之间相互通信需要通过系统调用来进行。</p>
<p>Linux系统中，一个进程可以在内核态（Kernel Mode）或用户态（UserMode）下执行，因此，linux内核栈和用户栈是分开的。用户栈用于进程在用户态下临时保存调用函数的参数、局部变量等数据。内核栈则含有内核程序执行函数调用时的信息。</p>
<div class="mceTemp">
<dl class="wp-caption alignnone" style="width: 587px;">
<dt class="wp-caption-dt"><img title="进程状态及转换关系" src="http://farm5.static.flickr.com/4154/5222725379_d0d6dea072_z.jpg" alt="" width="577" height="341" /></dt>
</dl>
</div>
<p>当进程正在被CPU执行时，被称为处于执行状态（running）。当进程正在等待系统中的资源而处于等待状态时，则称其处于睡眠等待状态。在Linux系统中，可分为可中断的和不可中断的等待状态。当系统资源已经可用时，进程就被唤醒而进入准备运行状态，该状态称为就绪状态。当进程已经停止运行，但其父进程还没有询问其状态时，则称该进程处于僵死状态。当进程被终止时，称其处于停止状态。</p>
<p>只有当进程从“内核运行态”转移到“睡眠状态”时，内核才会进行进程切换操作。在内核态下运行的进程不能被其他进程抢占，而且一个进程不能改变另一个进程的状态。为了避免进程切换时造成内核数据错误，内核在执行临界区代码时会禁止一切中断。</p>
<p><strong>Linux内核对内存的使用方法</strong><br />
为了有效地使用系统的物理内存，内存被划分成几个功能区域</p>
<div class="mceTemp">
<dl class="wp-caption alignnone" style="width: 587px;">
<dt class="wp-caption-dt"><img title="物理内存使用的功能分布图" src="http://farm6.static.flickr.com/5206/5222725381_b7ce070fbb_z.jpg" alt="" width="577" height="251" /></dt>
</dl>
</div>
<p>其中，linux内核程序占据物理内存的开始部分，接下来是用供硬盘或软盘等块设备使用的高速缓冲区部分。当一个进程需要读取块设备中的数据时，系统会首先将数据读到高速缓冲区中；当有数据需要写到块设备上去时，系统也是先将数据放到调整缓冲区中，然后由块设备驱动程序写到设备上。最后部分是供所有程序可以随时申请使用的主内存部分。内核程序在使用主内存区时，也同样要首先向内核的内存管理模块提出申请，在申请成功后方能使用。对于含有RAM虚拟盘的系统，主内存区头部还要划去一部分，供虚拟盘存放数据。</p>
<p>注：节选自《linux内核完全注释》，有改动。</p>
<p style="font-weight: bold;">&copy; 2010, <a href="http://chenzhiwei.net">chenzhiwei.net</a>. 版权所有.  <br />本文永久链接：<a title="Linux内核体系结构" href="http://chenzhiwei.net/2010/12/linux-kernel-architecture/">http://chenzhiwei.net/2010/12/linux-kernel-architecture/</a></p><hr /><div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://chenzhiwei.net/2010/12/the-basic-structure-of-linux-kernel/" title="Linux内核基本结构">Linux内核基本结构</a></li><li><a href="http://chenzhiwei.net/2010/12/makefile-in-linux-kernel/" title="Linux内核代码中的Makefile文件">Linux内核代码中的Makefile文件</a></li><li><a href="http://chenzhiwei.net/2010/03/install-ubuntu-under-windows/" title="windows下硬盘安装ubuntu的方法">windows下硬盘安装ubuntu的方法</a></li><li><a href="http://chenzhiwei.net/2011/08/shell-io-redirection/" title="Shell I/O重定向">Shell I/O重定向</a></li><li><a href="http://chenzhiwei.net/2011/07/one-apache-hosts-two-site-with-different-port/" title="一个apache为两个不同端口的网站提供服务">一个apache为两个不同端口的网站提供服务</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://chenzhiwei.net/2010/12/linux-kernel-architecture/feed/</wfw:commentRss>
		<slash:comments>2</slash:comments>
		</item>
		<item>
		<title>几个简单的shell脚本</title>
		<link>http://chenzhiwei.net/2010/11/shell-script-study-notes-shell/</link>
		<comments>http://chenzhiwei.net/2010/11/shell-script-study-notes-shell/#comments</comments>
		<pubDate>Mon, 29 Nov 2010 07:10:19 +0000</pubDate>
		<dc:creator>zhiwei</dc:creator>
				<category><![CDATA[编程相关]]></category>
		<category><![CDATA[Linux]]></category>
		<category><![CDATA[script]]></category>
		<category><![CDATA[shell]]></category>

		<guid isPermaLink="false">http://chenzhiwei.net/?p=30389</guid>
		<description><![CDATA[最近一直没有更新博客，这次更新就写几个shell脚本，很简单的那种，大牛们可以略过了。这里的几个脚本分别是用for、while、until循环写的从1加到100，判断当前目录下的文件是否为普通文件，如果是则移动到家目录，还有一个是在网上看到的面试题目。 从1加到100的三种实现方法： for循环 1 2 3 4 5 6 7 #!/bin/bash sum=0 for count in `seq 1 100` do sum=$((sum+count)) done echo &#34;1+2+...+100=$sum&#34; while循环 1 2 3 4 5 6 7 8 9 #!/bin/bash count=1 sum=0 while test $count -le 100 do sum=$((sum+count)) count=$((count+1)) done echo &#34;1+2+...+100=$sum&#34; until循环 1 2 3 4 5 6 7 [...]]]></description>
			<content:encoded><![CDATA[<p>最近一直没有更新博客，这次更新就写几个shell脚本，很简单的那种，大牛们可以略过了。这里的几个脚本分别是用for、while、until循环写的从1加到100，判断当前目录下的文件是否为普通文件，如果是则移动到家目录，还有一个是在网上看到的面试题目。<span id="more-30389"></span></p>
<p><strong>从1加到100的三种实现方法：</strong></p>
<p>for循环</p>

<div class="wp_syntax"><table><tr><td class="line_numbers"><pre>1
2
3
4
5
6
7
</pre></td><td class="code"><pre class="shell" style="font-family:monospace;">#!/bin/bash
sum=0
for count in `seq 1 100`
do
    sum=$((sum+count))
done
echo &quot;1+2+...+100=$sum&quot;</pre></td></tr></table></div>

<p>while循环</p>

<div class="wp_syntax"><table><tr><td class="line_numbers"><pre>1
2
3
4
5
6
7
8
9
</pre></td><td class="code"><pre class="shell" style="font-family:monospace;">#!/bin/bash
count=1
sum=0
while test $count -le 100
do
    sum=$((sum+count))
    count=$((count+1))
done
echo &quot;1+2+...+100=$sum&quot;</pre></td></tr></table></div>

<p>until循环</p>

<div class="wp_syntax"><table><tr><td class="line_numbers"><pre>1
2
3
4
5
6
7
8
9
</pre></td><td class="code"><pre class="shell" style="font-family:monospace;">#!/bin/bash
count=1
sum=0
until test $count -gt 100
do
    sum=$((sum+count))
    count=$((count+1))
done
echo &quot;1+2+...+100=$sum&quot;</pre></td></tr></table></div>

<p><strong>判断文件是否为普通文件并移动文件：</strong></p>

<div class="wp_syntax"><table><tr><td class="line_numbers"><pre>1
2
3
4
5
6
</pre></td><td class="code"><pre class="shell" style="font-family:monospace;">#!/bin/bash
read -p &quot;filename:&quot; filename
if [ -f &quot;$filename&quot; ]
then
    cp $filename ~/test
fi</pre></td></tr></table></div>

<p><strong>有两个文本文件中存放着N多QQ号，每行一个。用shell脚本找出两个文件中相同的QQ号：</strong></p>

<div class="wp_syntax"><table><tr><td class="line_numbers"><pre>1
2
3
4
5
6
7
8
9
10
11
12
</pre></td><td class="code"><pre class="shell" style="font-family:monospace;">#!/bin/bash
for stra in `cat a.txt`
do
    for strb in `cat b.txt`
    do
        if [ &quot;$stra&quot; -eq &quot;$strb&quot; ]
        then
            echo $stra &gt;&gt; c.txt
            echo &quot;$stra&quot;
        fi
    done
done</pre></td></tr></table></div>

<p>听说这是腾讯的面试题目。<br />
注：这些都是超级简单的脚本，入门专用的，一看就明白。</p>
<p style="font-weight: bold;">&copy; 2010, <a href="http://chenzhiwei.net">chenzhiwei.net</a>. 版权所有.  <br />本文永久链接：<a title="几个简单的shell脚本" href="http://chenzhiwei.net/2010/11/shell-script-study-notes-shell/">http://chenzhiwei.net/2010/11/shell-script-study-notes-shell/</a></p><hr /><div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://chenzhiwei.net/2010/11/shell-script-study-notes-2/" title="shell 脚本学习之判断条件">shell 脚本学习之判断条件</a></li><li><a href="http://chenzhiwei.net/2010/11/shell-script-study-notes/" title="shell脚本学习">shell脚本学习</a></li><li><a href="http://chenzhiwei.net/2011/08/shell-io-redirection/" title="Shell I/O重定向">Shell I/O重定向</a></li><li><a href="http://chenzhiwei.net/2010/10/linux-shell-study-notes-part-5/" title="Linux Shell学习笔记（五）">Linux Shell学习笔记（五）</a></li><li><a href="http://chenzhiwei.net/2010/07/linux-shell-study-notes-part-4/" title="linux shell 学习笔记(四)">linux shell 学习笔记(四)</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://chenzhiwei.net/2010/11/shell-script-study-notes-shell/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>shell 脚本学习之判断条件</title>
		<link>http://chenzhiwei.net/2010/11/shell-script-study-notes-2/</link>
		<comments>http://chenzhiwei.net/2010/11/shell-script-study-notes-2/#comments</comments>
		<pubDate>Sat, 20 Nov 2010 02:54:09 +0000</pubDate>
		<dc:creator>zhiwei</dc:creator>
				<category><![CDATA[编程相关]]></category>
		<category><![CDATA[Linux]]></category>
		<category><![CDATA[script]]></category>
		<category><![CDATA[shell]]></category>
		<category><![CDATA[脚本]]></category>

		<guid isPermaLink="false">http://chenzhiwei.net/?p=30391</guid>
		<description><![CDATA[在之前的shell语言学习笔记中已经写过shell的几种判断语句及循环语句，也简单的介绍了shell语言判断语句和判断条件。在此再做进一步学习。 test命令的测试功能 test命令用于检测系统文件及其相关属性，如检查某文件是否存在，检查某文件的权限等。判断当前目录下是否存在某文件study可以用以下命令： 1 #test -e study -e 选项是测试某文件是否存在（包括文件和文件夹），该执行结果不会输出任何信息，但是我们可以通过&#38;&#38;及&#124;&#124;来改写使其展现相关信息，改写后的命令如下： 1 #test -e study &#38;&#38; echo &#34;exist!&#34; &#124;&#124; echo &#34;not exist!&#34; 该命令的作用就是当study文件存在时就输出字符串”exist!”，当不存在时就输出字符串”not exist!” 以下是test命令常用的测试标志： 1. 某文件名的类型检测（存在与否及文件类型）（test -e filename） -e :该“文件名”是否存在。 -d :该文件名是否为目录。 -f  :该文件名是否为普通文件。 b,c,S,p,L分别指的是块设备、字符设备、套接字文件、管道文件及链接文件。 2. 文件权限的检测（test -r filename） -r :该文件是否具有可读属性 -w :该文件是否具有可写属性 -x :该文件是否具有可执行属性 -s  :该文件是否为非空白文件 3. 比较两个文件（test file_a nt file_b） -nt :文件file_a是否比file_b新 -ot :文件file_a是否比file_b旧 [...]]]></description>
			<content:encoded><![CDATA[<p>在之前的shell语言学习笔记中已经写过shell的几种判断语句及循环语句，也简单的介绍了shell语言判断语句和判断条件。在此再做进一步学习。<br />
<span id="more-30391"></span><br />
<strong>test命令的测试功能</strong></p>
<p>test命令用于检测系统文件及其相关属性，如检查某文件是否存在，检查某文件的权限等。判断当前目录下是否存在某文件study可以用以下命令：</p>

<div class="wp_syntax"><table><tr><td class="line_numbers"><pre>1
</pre></td><td class="code"><pre class="shell" style="font-family:monospace;">#test -e study</pre></td></tr></table></div>

<p>-e 选项是测试某文件是否存在（包括文件和文件夹），该执行结果不会输出任何信息，但是我们可以通过&amp;&amp;及||来改写使其展现相关信息，改写后的命令如下：</p>

<div class="wp_syntax"><table><tr><td class="line_numbers"><pre>1
</pre></td><td class="code"><pre class="shell" style="font-family:monospace;">#test -e study &amp;&amp; echo &quot;exist!&quot; || echo &quot;not exist!&quot;</pre></td></tr></table></div>

<p>该命令的作用就是当study文件存在时就输出字符串”exist!”，当不存在时就输出字符串”not exist!”</p>
<p>以下是test命令常用的测试标志：</p>
<p>1. 某文件名的类型检测（存在与否及文件类型）（test -e filename）</p>
<p>-e :该“文件名”是否存在。<br />
-d :该文件名是否为目录。<br />
-f  :该文件名是否为普通文件。<br />
b,c,S,p,L分别指的是块设备、字符设备、套接字文件、管道文件及链接文件。</p>
<p>2. 文件权限的检测（test -r filename）</p>
<p>-r :该文件是否具有可读属性<br />
-w :该文件是否具有可写属性<br />
-x :该文件是否具有可执行属性<br />
-s  :该文件是否为非空白文件</p>
<p>3. 比较两个文件（test file_a nt file_b）</p>
<p>-nt :文件file_a是否比file_b新<br />
-ot :文件file_a是否比file_b旧<br />
-ef :判断两个文件是否为同一文件，可用于判断硬连接。（主要判断两个文件是否均指向同一个inode）</p>
<p>4. 两个整数之间的判断（test n1 -eq n2）</p>
<p>-eq :两个数相等（equal）<br />
-ne :两个数不相等（not equal）<br />
-gt :前者大于后者（greater than）<br />
-lt :前者小于后者（less than）<br />
-ge :前者大于等后者<br />
-le :前者小于等于后者</p>
<p>5. 判断字符串</p>
<p>test -z str :判断字符串是否为空，若为空则回传true<br />
test -n str :判断字符串是否为非空，左路为非空则回传true（-n亦可省略）<br />
test str_a = str_b及test str_a != str_b:判断两字条串是否相等及不相等。</p>
<p>6. 多重判断条件（test -r file -a -w file）</p>
<p>-a :and，当两个条件都满足时才回传true，即file具有读和写权限<br />
-o : or，当两个条件满足其一时即回传true<br />
-! :条件求反，test -! -x file，即当file不具有执行权限时才回传true</p>
<p>下面是两个简单的shell脚本，判断其功能：</p>

<div class="wp_syntax"><table><tr><td class="line_numbers"><pre>1
2
3
4
</pre></td><td class="code"><pre class="shell" style="font-family:monospace;">#!/bin/bash
echo &quot;Please input a filename:&quot;
read -e  filename
(test -e $filename &amp;&amp; (test -d $filename &amp;&amp; echo &quot;directory&quot; ||( test -f $filename &amp;&amp; echo &quot;regular&quot;)) )||echo &quot;$filename does not exist&quot;</pre></td></tr></table></div>


<div class="wp_syntax"><table><tr><td class="line_numbers"><pre>1
2
3
4
5
6
7
8
9
10
11
12
</pre></td><td class="code"><pre class="shell" style="font-family:monospace;">#!/bin/bash
echo -e &quot;The program will show you that filename is exist which input by you.&quot;
read -p &quot;Input a filename:&quot; filename
test -z $filename &amp;&amp; echo &quot;You must input a filename.&quot; &amp;&amp; exit 0
test ! -e $filename &amp;&amp; echo &quot;The filename $filename DO NOT exist&quot; &amp;&amp; exit 0
test -f $filename &amp;&amp; filetype=&quot;Regulare file&quot;
test -d $filename &amp;&amp; filetype=&quot;directory&quot;;
test -r $filename &amp;&amp; perm=&quot;readable&quot;
test -w $filename &amp;&amp; perm=&quot;$perm writable&quot;
test -x $filename &amp;&amp; perm=&quot;$perm executable&quot;
echo &quot;The filename:$filename is a $filetype&quot;
echo &quot;And the permission are:$perm&quot;</pre></td></tr></table></div>

<p><strong>使用判断符号[ ]</strong></p>
<p>可以使用判断符号进行数据的判断，如检查某变量是否为空 [ -z $SHELL ]，需要注意的是中括号（“[]”）内的组件必须以空格隔开。有以下脚本：</p>

<div class="wp_syntax"><table><tr><td class="line_numbers"><pre>1
2
3
4
5
</pre></td><td class="code"><pre class="shell" style="font-family:monospace;">#!/bin/bash
read -p &quot;input you choice:&quot; choice
[ &quot;$choice&quot; == &quot;y&quot; ] || [ &quot;$choice&quot; == &quot;Y&quot; ] &amp;&amp; echo &quot;OK,continue&quot; &amp;&amp; exit 0
[ &quot;$choice&quot; == &quot;n&quot; ] || [ &quot;$choice&quot; == &quot;N&quot; ] &amp;&amp; echo &quot;Oh,interrupt!&quot; &amp;&amp; exit 0
echo &quot;I don't know what is your choice&quot; &amp;&amp; exit 0</pre></td></tr></table></div>

<p>注：这些内容是参考的《鸟哥的Linux私房菜》一书中的部分章节。</p>
<p style="font-weight: bold;">&copy; 2010, <a href="http://chenzhiwei.net">chenzhiwei.net</a>. 版权所有.  <br />本文永久链接：<a title="shell 脚本学习之判断条件" href="http://chenzhiwei.net/2010/11/shell-script-study-notes-2/">http://chenzhiwei.net/2010/11/shell-script-study-notes-2/</a></p><hr /><div  class="related_post_title">相关日志</div><ul class="related_post"><li><a href="http://chenzhiwei.net/2010/11/shell-script-study-notes/" title="shell脚本学习">shell脚本学习</a></li><li><a href="http://chenzhiwei.net/2010/11/shell-script-study-notes-shell/" title="几个简单的shell脚本">几个简单的shell脚本</a></li><li><a href="http://chenzhiwei.net/2011/08/shell-io-redirection/" title="Shell I/O重定向">Shell I/O重定向</a></li><li><a href="http://chenzhiwei.net/2010/10/linux-shell-study-notes-part-5/" title="Linux Shell学习笔记（五）">Linux Shell学习笔记（五）</a></li><li><a href="http://chenzhiwei.net/2010/07/linux-shell-study-notes-part-4/" title="linux shell 学习笔记(四)">linux shell 学习笔记(四)</a></li></ul>]]></content:encoded>
			<wfw:commentRss>http://chenzhiwei.net/2010/11/shell-script-study-notes-2/feed/</wfw:commentRss>
		<slash:comments>22</slash:comments>
		</item>
	</channel>
</rss>

