花了點時間把svnbook看了遍，對于svn有了個比較好的認識。svn info時，修訂版和最后修改的修訂版總是讓我感覺很困惑。要搞明白這個需要對下面幾個關(guān)鍵字有所了解。

HEAD：版本庫中的最新版本。

COMMITED：文件最后提交生成的版本號。

PREV：文件倒數(shù)第二次提交生成的版本號。

BASE：目錄簽出或者簽入生成的版本號。

HEAD、COMMITED和PREV比較好理解，BASE比較難于理解。假設(shè)一個目錄下有兩個文件configure.ac和Makefile.am，第一次將它們check out出來時，會生成一個新的revision，這個便是BASE了。此時使用svn info configure.ac/Makefile.am可以發(fā)現(xiàn)它們的修訂版是一樣的，但是最后修改的修訂版不同。這里的修訂版對應(yīng)其實就是BASE，而最后修改的修訂版則是COMMITED。插一句，很多人很容易誤解為啥修訂版號和最后修改的修訂版號不一致。

若將configure.ac修改并check in，這個時候會生成一個新的revision，configure.ac的BASE和COMMITED的值相當。而svn info Makefile.am，發(fā)現(xiàn)它的BASE和COMMITED沒有改變。svn up一下，發(fā)現(xiàn)Makefile.am的BASE會變成最新的，和configure.ac相同。

簽出代碼庫。

顯示修訂版（BASE）和最后修改的修訂版（COMMITED）。

修改Makefile.am并簽入看看。

svn update一下看看。

svn一個版本庫的revision是全局的，不管是在trunk還是branch，也不管使用merge合并代碼還是消除修改，簽入和簽出都會生成一個新的revision。當項目中一個文件簽入時會導(dǎo)致別的文件的BASE暫時低于HEAD，但是一旦update，二者將保持一致。

unset LANGUAGE
export LANG="en"
cd /home/kingsoft
mkdir distcc
cd distcc

rpm包用：rpm -ivh ...
bz2包用：tar -xvf ...
進入distcc解壓后的目錄
./configure && make && make install
mkdir /usr/lib/distcc
mkdir /usr/lib/distcc/bin
cd /usr/lib/distcc/bin
ln -s /usr/local/bin/distcc gcc
ln -s /usr/local/bin/distcc cc
ln -s /usr/local/bin/distcc g++
ln -s /usr/local/bin/distcc c++

進入ccache解壓目錄
./configure && make && make install

mkdir /Data
mkdir /Data/Cache
mkdir /Data/Cache/CCache
cd /Data/Cache
touch /var/log/distccd.log

vim ~/.bash_profile
把 /usr/lib/distcc/bin 加到PATH
并添加下面內(nèi)容
## ----- Distcc -----
#
DISTCC_HOSTS="localhost 192.168.1.1"
DISTCC_VERBOSE=1
DISTCC_LOG="/var/log/distcc.log"
export DISTCC_HOSTS PATH DISTCC_VERBOSE DISTCC_LOG
#
## ----- End -----

## ----- Ccache -----
#
# export CCACHE_DISABLE=1
CCACHE_DIR=/Data/Cache/CCache
CCACHE_LOGFILE=/Data/Cache/CCache.log
CCACHE_PREFIX="distcc"
CC="ccache gcc"
CXX="ccache g++"
export CCACHE_DIR CCACHE_LOGFILE CCACHE_PREFIX CC CXX
#
## ----- End -----

vim /etc/rc.local
distccd --daemon --allow 10.20.0.0/16

==========================================
啟動監(jiān)控：distccd --daemon --allow 10.20.0.0/16
查看監(jiān)控：distccmon-text 1

Nagle算法的基本定義是任意時刻，最多只能有一個未被確認的小段。 所謂“小段”，指的是小于MSS尺寸的數(shù)據(jù)塊，所謂“未被確認”，是指一個數(shù)據(jù)塊發(fā)送出去后，沒有收到對方發(fā)送的ACK確認該數(shù)據(jù)已收到。

舉個例子，比如之前的blog中的實驗，一開始client端調(diào)用socket的write操作將一個int型數(shù)據(jù)(稱為A塊)寫入到網(wǎng)絡(luò)中，由于此時連接是空閑的（也就是說還沒有未被確認的小段），因此這個int型數(shù)據(jù)會被馬上發(fā)送到server端，接著，client端又調(diào)用write操作寫入‘\r\n’（簡稱B塊），這個時候，A塊的ACK沒有返回，所以可以認為已經(jīng)存在了一個未被確認的小段，所以B塊沒有立即被發(fā)送，一直等待A塊的ACK收到（大概40ms之后），B塊才被發(fā)送。整個過程如圖所示：

這里還隱藏了一個問題，就是A塊數(shù)據(jù)的ACK為什么40ms之后才收到？這是因為TCP/IP中不僅僅有nagle算法，還有一個ACK延遲機制 。當Server端收到數(shù)據(jù)之后，它并不會馬上向client端發(fā)送ACK，而是會將ACK的發(fā)送延遲一段時間（假設(shè)為t），它希望在t時間內(nèi)server端會向client端發(fā)送應(yīng)答數(shù)據(jù)，這樣ACK就能夠和應(yīng)答數(shù)據(jù)一起發(fā)送，就像是應(yīng)答數(shù)據(jù)捎帶著ACK過去。在我之前的時間中，t大概就是40ms。這就解釋了為什么'\r\n'(B塊)總是在A塊之后40ms才發(fā)出。

如果你覺著nagle算法太搗亂了，那么可以通過設(shè)置TCP_NODELAY將其禁用 。當然，更合理的方案還是應(yīng)該使用一次大數(shù)據(jù)的寫操作，而不是多次小數(shù)據(jù)的寫操作。

本文來自CSDN博客，轉(zhuǎn)載請標明出處：http://blog.csdn.net/historyasamirror/archive/2011/05/15/6423235.aspx

ldd查看應(yīng)用程序鏈接了哪些動態(tài)庫。

nm列出目標文件中包含的符號信息。

size列出各個段的大小及總的大小。

strings列出文件中的字符串。

readelf讀取elf文件的完整結(jié)構(gòu)。

objdump導(dǎo)出目標文件的相關(guān)信息（elf文件相關(guān)工具的源頭）。

gdb對文件的執(zhí)行過程進行調(diào)試分析，設(shè)置斷點(b)、單步執(zhí)行(n)、函數(shù)調(diào)用追蹤(bt)、反匯編(disassemble)。

strace跟蹤程序中的系統(tǒng)調(diào)用及信號處理信息。

LD_DEBUG通過設(shè)置這個環(huán)境變量，可以方便的看到 loader 的加載過程（包括庫的加載，符號解析等過程），使用【LD_DEBUG=help 可執(zhí)行文件路徑】可查看使用幫助。

LD_PRELOAD環(huán)境變量指定的共享庫會被預(yù)先加載，如果出現(xiàn)重名的函數(shù)，預(yù)先加載的函數(shù)將會被調(diào)用，如在預(yù)先加載的庫中包含自定義的puts函數(shù)，則在執(zhí)行程序時將使用自定義版本的puts函數(shù)，而不是libc庫中的puts函數(shù)。

proc文件系統(tǒng)中包含進程的地址空間映射關(guān)系，具體查看/proc/進程id/maps文件的內(nèi)容。

valgrind工具對可執(zhí)行程序文件進行內(nèi)存檢查（還有cache模擬、調(diào)用過程跟蹤等功能），以避免內(nèi)存泄露等問題。

addrline將可執(zhí)行文件中的地址轉(zhuǎn)換為其在源文件中對應(yīng)的位置（文件名：行號）。

處理器總處于以下狀態(tài)中的一種：
１、內(nèi)核態(tài)，運行于進程上下文，內(nèi)核代表進程運行于內(nèi)核空間；
２、內(nèi)核態(tài)，運行于中斷上下文，內(nèi)核代表硬件運行于內(nèi)核空間；
３、用戶態(tài)，運行于用戶空間。

用戶空間的應(yīng)用程序，通過系統(tǒng)調(diào)用，進入內(nèi)核空間。這個時候用戶空間的進程要傳遞很多變量、參數(shù)的值給內(nèi)核，內(nèi)核態(tài)運行的時候也要保存用戶進程的一些寄存器值、變量等。所謂的“進程上下文”，可以看作是用戶進程傳遞給內(nèi)核的這些參數(shù)以及內(nèi)核要保存的那一整套的變量和寄存器值和當時的環(huán)境等。

硬件通過觸發(fā)信號，導(dǎo)致內(nèi)核調(diào)用中斷處理程序，進入內(nèi)核空間。這個過程中，硬件的一些變量和參數(shù)也要傳遞給內(nèi)核，內(nèi)核通過這些參數(shù)進行中斷處理。所謂的“中斷上下文”，其實也可以看作就是硬件傳遞過來的這些參數(shù)和內(nèi)核需要保存的一些其他環(huán)境（主要是當前被打斷執(zhí)行的進程環(huán)境）。

本文來自CSDN博客，轉(zhuǎn)載請標明出處：http://blog.csdn.net/eroswang/archive/2007/11/28/1905830.aspx

在實模式下沒有引入段式內(nèi)存管理模式前,程序都是使用絕對地址來進行內(nèi)存操作的,這樣造成了程序的可移植性差等問題。于 是在8086時代開始引入段式內(nèi)存管理,段式管理引入了地址映射的概念,不但解決了可移植性問題，也解決了16位ALU和段寄存器的可尋址限制,即支持更 大的內(nèi)存尋址.每個段的大小是64KB.

在實模式下,由于系統(tǒng)程序和用戶程序在訪問內(nèi)存等資源時權(quán)限沒有區(qū)分,所以很可能造成操作系統(tǒng)出現(xiàn)異常.于是Intel在80286時代開發(fā)出來了保護模式.

而Intel為了兼容80386前的處理器就規(guī)定：在IA(Intel Arch)32保護模式下，不能禁止分段，但是分頁是Optional的。/*When operating in protected mode, some form of segmentation must be used. There is no mode bit to disable segmentation. The use of paging, however, is optional.*/.

既然linux在內(nèi)存管理上不能禁止分段,那么linux又認為分段會造成大量的內(nèi)存碎片,所以就通過將邏輯地址中的段基址置為0,加上偏移量形成線性地址,來簡化段式管理內(nèi)存而使用分頁管理內(nèi)存的。

在IA32下,每頁是4K.

二、linux的三種類型內(nèi)存地址及關(guān)系是什么樣的？

分段                     分頁

邏輯地址————> 線性地址 —————->物理地址

在 x86 架構(gòu)中，內(nèi)存被劃分成 3 種類型的地址：

邏輯地址 (logical address) 由16位段選擇符:32位偏移量來表示，它有可能直接對應(yīng)于一個物理位置(Intel實模式下)。

線性地址 (linear address)或虛擬地址 是由段描述符中的32位段基址和邏輯地址中的32位偏移量相加構(gòu)成的。例如:0x08048394,由于linux把所有的段基址都置為0x00000000.所以線性地址=0x00000000+偏移量=邏輯地址,在不分頁的情況下：線性地址就直接是物理地址;

物理地址 (physical address) 是使用物理地址總線中的位表示的地址。內(nèi)存管理單元可以將邏輯地址轉(zhuǎn)換成物理地址。

三、為什么在32位的操作系統(tǒng)下每個進程會有4G的內(nèi)存使用限制?

由于32位操作系統(tǒng)下,由于虛擬地址空間是2的32次方=4 294 967 296,通常的數(shù)據(jù)對象都以字節(jié)為單位,所以一個進程的可尋址范圍就是4G內(nèi)存

四、為什么linux服務(wù)器是32位的還可以認出來多于4G的內(nèi)存?

本來在IA32下,機器只能認出4G的內(nèi)存,但Intel為了讓32位的OS能支持更多的內(nèi)存。采取了PAE(Physical Address Extension, 物理地址擴展)技術(shù).PAE的支持,不僅需要處理器的支持,OS的內(nèi)核也需要支持才可行(我們通常采用的RHEL3/4/5 kernel都支持PAE),也就是處理器內(nèi)部增加了PAE寄存器,用于記錄多出的4條地址總線，所以系統(tǒng)就是2^36=64G.

五、在32位的linux操作系統(tǒng)下,為什么linux系統(tǒng)認出來的內(nèi)存大于4G,而我的程序每個進程卻只能分配4G以下的內(nèi)存?

雖然Intel為其處理器為支持PAE增加了4條地址線，但因為虛擬地址是32位的,所以單個進程還是只能分配4G以下的內(nèi)存

Note: Linux can use up to 64 Gigabytes of physical memory on x86 systems. However, the address space of 32-bit x86 processors is only 4 Gigabytes large. Thus means that, if you have a large amount of physical memory, not all of it can be “permanently mapped” by the kernel. The physical memory that’s not permanently mapped is called “high memory”.

Redhat網(wǎng)站http://www.redhat.com/rhel/compare/

六、32位的RedHat linux在”smp” kernel和”hugemem” kernel中內(nèi)存支持方面有什么建議?

Smp kernel和hugemem kernel都支持PAE支持,也就意味著最大能支持64G的內(nèi)存。而RedHat建議當你的物理內(nèi)存在16GB之內(nèi),用SMP” kernel,在16GB-64GB之間使用”Hugemem” kernel.這是因為虛擬地址空間里有1G用于內(nèi)核空間，而3G用于用戶空間。而關(guān)健的一些數(shù)據(jù)結(jié)構(gòu)是存放在1G內(nèi)核空間的，在管理32G內(nèi)存當中，需 要用到0.5G來用于管理這些物理內(nèi)存(容易觸發(fā)OOM killer).雖然32位OS下,內(nèi)核和用戶空間的比例都是1：3，但Hugemem打了一個補丁,使比例成為4G:4G,即使內(nèi)核空間和用戶空間相互 獨立，所以也會有性能上的損失,因為應(yīng)用程序的運行,通常會有內(nèi)核和用戶空間的切換。所以如果你的內(nèi)存大于16G,建議你使用64位的OS。

/* The “SMP” kernel supports a maximum of 16GB of main memory. Systems with more than 16GB of main memory use the “Hugemem” kernel. In certain workload scenarios it may be advantageous to use the “Hugemem” kernel on systems with more than 12GB of main memory. */

七、我們通常malloc了4K內(nèi)存,到底是怎么對應(yīng)到物理內(nèi)存的？

在linux下,處理器在得到內(nèi)存的線性地址進行內(nèi)存尋址時，不是直接在內(nèi)存的物理地址里查找的，而是通過線性地址轉(zhuǎn)換到主內(nèi)存的物理地 址，TLB(Translation lookaside buffer,可以簡單的理解為:一種存儲線性地址和物理地址的硬件高速緩沖器)就是負責(zé)將虛擬內(nèi)存地址翻譯成實際的物理內(nèi)存地址，而CPU尋址時會優(yōu)先 在TLB中進行尋址。如果TLB里沒有,則從頁表里進行線性地址到物理地址的轉(zhuǎn)換.hugepage能增加TLB的命中率，所以會在某些方面能大大提高系 統(tǒng)性能)。

1、邏輯地址轉(zhuǎn)線性地址

a、首先根據(jù)指令的性質(zhì)來確定該使用哪一個段寄存器。
b、根據(jù)段寄存器的內(nèi)容，到GDT中找到相應(yīng)的“段描述結(jié)構(gòu)”

c、根據(jù)linux把所有的段基址都置為0×00000000.所以0×00000000+偏移量就是線性地址了.在不分頁的情況下：線性地址就直接是物理地址;
同時，在上面過程中，由于有對訪問權(quán)限的檢查，就實現(xiàn)了保護。

2、線性地址轉(zhuǎn)物理地址

在保護模式下，控制寄存器CR0的最高位PG位(PE位控制是否為保護模式)控制著分頁管理機制是否生效，如果PG=1，分頁機制生效，需通過頁表查找才能把線性地址轉(zhuǎn)換物理地址。如果PG=0，則分頁機制無效，線性地址就直接做為物理地址。

頁式內(nèi)存管理中，32位的線性地址劃分為三個部分：10位的頁目錄表下標、10位的頁面表下標、12位的頁內(nèi)偏移量。CPU增加了一個CR3寄存器存放指向當前頁目錄表的指針。尋址方式就改為：
a、從CR3取得頁目錄表的基地址；
b、根據(jù)10位頁目錄表下標和從CR3取得的基地址，得到相應(yīng)頁表的基地址；
c、根據(jù)10位頁面表下標和b中得到的頁表基地址，從頁面表中取得相應(yīng)的頁面描述項；
d、將頁面描述項中的頁面基地址和線性地址中的12位頁內(nèi)地址偏移相加，得到物理地址。
同時，在地址轉(zhuǎn)換的過程中也有越界和權(quán)限的檢查，就不贅述了。

注:傳統(tǒng)的32位操作系統(tǒng)采用的是兩級分頁模型

64位和PAE支持都采用了三級分頁模型

1進程啟動的時候，其（虛擬）內(nèi)存空間的初始布局如圖1所示。其中，mmap內(nèi)存映射文件是在堆和棧的中間（例如libc-2.2.93.so，其它數(shù)據(jù)文件等），為了簡單起見，省略了內(nèi)存映射文件。_edata指針（glibc里面定義）指向數(shù)據(jù)段的最高地址。
2 進程調(diào)用A=malloc(30K)以后，內(nèi)存空間如圖2：malloc函數(shù)會調(diào)用brk系統(tǒng)調(diào)用，將_edata指針往高地址推30K，就完成虛擬內(nèi)存 分配。你可能會問：只要把_edata+30K就完成內(nèi)存分配了？事實是這樣的，_edata+30K只是完成虛擬地址的分配，A這塊內(nèi)存現(xiàn)在還是沒有物 理頁與之對應(yīng)的，等到進程第一次讀寫A這塊內(nèi)存的時候，發(fā)生缺頁中斷，這個時候，內(nèi)核才分配A這塊內(nèi)存對應(yīng)的物理頁。也就是說，如果用malloc分配了 A這塊內(nèi)容，然后從來不訪問它，那么，A對應(yīng)的物理頁是不會被分配的。
3進程調(diào)用B=malloc(40K)以后，內(nèi)存空間如圖3.

4進程調(diào)用C=malloc(200K)以后，內(nèi)存空間如圖4：默認情況下，malloc函數(shù)分配內(nèi)存，如果請求內(nèi)存大于128K（可由 M_MMAP_THRESHOLD選項調(diào)節(jié)），那就不是去推_edata指針了，而是利用mmap系統(tǒng)調(diào)用，從堆和棧的中間分配一塊虛擬內(nèi)存。這樣子做主 要是因為brk分配的內(nèi)存需要等到高地址內(nèi)存釋放以后才能釋放（例如，在B釋放之前，A是不可能釋放的），而mmap分配的內(nèi)存可以單獨釋放。當然，還有 其它的好處，也有壞處，再具體下去，有興趣的同學(xué)可以去看glibc里面malloc的代碼了。
5進程調(diào)用D=malloc(100K)以后，內(nèi)存空間如圖5.
6進程調(diào)用free(C)以后，C對應(yīng)的虛擬內(nèi)存和物理內(nèi)存一起釋放

4進程調(diào)用C=malloc(200K)以后，內(nèi)存空間如圖4：默認情況下，malloc函數(shù)分配內(nèi)存，如果請求內(nèi)存大于128K（可由 M_MMAP_THRESHOLD選項調(diào)節(jié)），那就不是去推_edata指針了，而是利用mmap系統(tǒng)調(diào)用，從堆和棧的中間分配一塊虛擬內(nèi)存。這樣子做主 要是因為brk分配的內(nèi)存需要等到高地址內(nèi)存釋放以后才能釋放（例如，在B釋放之前，A是不可能釋放的），而mmap分配的內(nèi)存可以單獨釋放。當然，還有 其它的好處，也有壞處，再具體下去，有興趣的同學(xué)可以去看glibc里面malloc的代碼了。
5進程調(diào)用D=malloc(100K)以后，內(nèi)存空間如圖5.
6進程調(diào)用free(C)以后，C對應(yīng)的虛擬內(nèi)存和物理內(nèi)存一起釋放

7進程調(diào)用free(B)以后，如圖7所示。B對應(yīng)的虛擬內(nèi)存和物理內(nèi)存都沒有釋放，因為只有一個_edata指針，如果往回推，那么D這塊內(nèi)存怎 么辦呢？當然，B這塊內(nèi)存，是可以重用的，如果這個時候再來一個40K的請求，那么malloc很可能就把B這塊內(nèi)存返回回去了。
8進程調(diào)用free(D)以后，如圖8所示。B和D連接起來，變成一塊140K的空閑內(nèi)存。
9默認情況下：當最高地址空間的空閑內(nèi)存超過128K（可由M_TRIM_THRESHOLD選項調(diào)節(jié)）時，執(zhí)行內(nèi)存緊縮操作（trim）。在上一個步驟free的時候，發(fā)現(xiàn)最高地址空閑內(nèi)存超過128K，于是內(nèi)存緊縮，變成圖9所示。

真相大白
說 完內(nèi)存分配的原理，那么被測模塊在內(nèi)核態(tài)cpu消耗高的原因就很清楚了：每次請求來都malloc一塊2M的內(nèi)存，默認情況下，malloc調(diào)用mmap 分配內(nèi)存，請求結(jié)束的時候，調(diào)用munmap釋放內(nèi)存。假設(shè)每個請求需要6個物理頁，那么每個請求就會產(chǎn)生6個缺頁中斷，在2000的壓力下，每秒就產(chǎn)生 了10000多次缺頁中斷，這些缺頁中斷不需要讀取磁盤解決，所以叫做minflt；缺頁中斷在內(nèi)核態(tài)執(zhí)行，因此進程的內(nèi)核態(tài)cpu消耗很大。缺頁中斷分 散在整個請求的處理過程中，所以表現(xiàn)為分配語句耗時（10us）相對于整條請求的處理時間（1000us）比重很小。

解決辦法
將動態(tài)內(nèi)存改為靜態(tài)分配，或者啟動的時候，用malloc為每個線程分配，然后保存在threaddata里面。但是，由于這個模塊的特殊性，靜態(tài)分配，或者啟動時候分配都不可行。另外，Linux下默認棧的大小限制是10M，如果在棧上分配幾M的內(nèi)存，有風(fēng)險。
禁止malloc調(diào)用mmap分配內(nèi)存，禁止內(nèi)存緊縮。
在進程啟動時候，加入以下兩行代碼：
mallopt(M_MMAP_MAX, 0); // 禁止malloc調(diào)用mmap分配內(nèi)存
mallopt(M_TRIM_THRESHOLD, -1); // 禁止內(nèi)存緊縮
效果：加入這兩行代碼以后，用ps命令觀察，壓力穩(wěn)定以后，majlt和minflt都為0。進程的系統(tǒng)態(tài)cpu從20降到10。

小結(jié)
可以用命令ps -o majflt minflt -C program來查看進程的majflt, minflt的值，這兩個值都是累加值，從進程啟動開始累加。在對高性能要求的程序做壓力測試的時候，我們可以多關(guān)注一下這兩個值。
如果一個進程使用了mmap將很大的數(shù)據(jù)文件映射到進程的虛擬地址空間，我們需要重點關(guān)注majflt的值，因為相比minflt，majflt對于性能的損害是致命的，隨機讀一次磁盤的耗時數(shù)量級在幾個毫秒，而minflt只有在大量的時候才會對性能產(chǎn)生影響。

在日常系統(tǒng)管理工作中，需要編寫腳本來完成特定的功能，編寫shell腳本是一個基本功了！
在編寫的過程中，掌握一些常用的技巧和語法就可以完成大部分功能了，也就是2/8原則.

1. 單引號和雙引號的區(qū)別

單引號與雙引號的最大不同在于雙引號仍然可以引用變量的內(nèi)容，但單引號內(nèi)僅是 普通字符 ，不會作變量的引用，直接輸出字符竄。請看如下例子：

  [root@linux ~]# name=HaHa

[root@linux ~]# echo $name

HaHa

[root@linux ~]# myname="$name is wow"

[root@linux ~]# echo $myname

HaHa is wow

[root@linux ~]# myname='$name is wow'

[root@linux ~]# echo $myname

$name is wow

從上面例子可以看出,使用了單引號的時候，那么$name只是普通字符,直接輸出而已！

2. 逐行讀取文件

• 使用for循環(huán)來讀取文件

    for line in `cat file.txt`
  
      do
  
      echo $line
  
      done

注意:由于使用for來讀入文件里的行時，會自動把空格和換行符作為一樣分隔符，如果行里有空格的時候，輸出的結(jié)果會很亂，所以只適用于行連續(xù)不能有空格或者換行符的文件

• 使用while循環(huán)讀取文件

    cat file.txt |while read line
  
      do
  
      echo $line
  
      done
  
      
  
      或者：
  
      
  
      while read line
  
      do
  
      echo $line
  
      done < file.txt

注意:由于使用while來讀入文件里的行時，會整行讀入，不會關(guān)注行的內(nèi)容(空格..)，所以比for讀文件有更好的適用性，推薦使用while循環(huán)讀取文件

3. bash shell 腳本中常用隱含變量

注意: $? 用于檢查上一個命令執(zhí)行是否正確(在Linux中，命令退出狀態(tài)為0表示該命令正確執(zhí)行，任何非0值表示命令出錯)
$$ 變量最常見的用途是用做暫存文件的名字以保證暫存文件不會重復(fù)。
$* 和 $@ 如果輸出是一樣的，但是在使用for循環(huán)，在使用 雙引號(”")引用時 “$*” 會輸出成一個元素 而 “$@” 會按照每個參數(shù)是一個元素方式輸出

請看測試例子

  #cat test.sh

#!/bin/sh

echo '"$@" output.....'

for i in "$@"

do

echo $i

done

echo '"$*" output ....'

for i in "$*"

do

echo $i

done

輸出結(jié)果

  #sh test.sh a b c d

"$@" output.....

a

b

c

d

"$*" output ....

a b c d

從輸出結(jié)果可以看出 “$*” 輸出是一行 而 “$@” 輸出則是四行

4. 變量內(nèi)容的刪除與替換

我們在一些情況下，需要對變量中的字符竄進行查找刪除或者替換，就需要使用下表列出的方法

舉例如下(刪除字符竄中的某個字符):

  [root@linux ~]# export test_str="/usr/kerberos/sbin:/usr/kerberos/bin:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/root/bin"

[root@linux ~]# echo ${test_str#/*kerberos/bin:}

/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/root/bin

5. 變量條件測試賦值

在某些時刻我們需要‘判斷’某個變量是否存在，若變量存在則將此變量值賦值給新的變量，若變量不存在則將其他值賦值給新的變量.

舉例如下:

  [root@linux ~]# test_name=""

[root@linux ~]# test_name=${test_name-root}

[root@linux ~]# echo $test_name

<== 因為 test_name 被設(shè)定為空字符竄！所以當然還是保留為空字符竄！

[root@linux ~]# test_name=${test_name:-root}

[root@linux ~]# echo $test_name

root  <== 加上‘:’后若變量內(nèi)容為空或者是未設(shè)定，都能夠以后面的內(nèi)容替換！

基本上這種變量的測試也能夠透過 shell script 內(nèi)的 if…then… 來處理,不過通過上述提及的簡單的方法來測試變量，是程序看起來更精簡一些！

6. shell 中分隔符 : 變量IFS 使用

shell腳本中，如果使用for循環(huán)一個字符竄的話，默認使用空格來分割字符竄. 還有前面所提到的 使用for循環(huán)逐行讀取文件內(nèi)容時候,文件行中如果有空格的話輸出的結(jié)果也會變亂. 這個時候 使用 IFS 變量來設(shè)置特定的字符竄分割符來，達到輸出正確的目的. 默認情況下 IFS 是使用 <space><tab><newline>， 空格 "t "n 來作為默認的分割符的.

我們將前面使用for逐行讀取文件的例子 改進下就可以輸出正確了,請看下面

  #!/bin/bash

IFS_old=$IFS      #將原IFS值保存，以便用完后恢復(fù)

IFS=$’"n’         #更改IFS值為$’"n’

for line in `cat file.txt`

do

echo $line

done

file.txt 文件內(nèi)容如下

  [root@linux]$ cat file.txt

sdfsdfsdfsdf

ssssss ssssss ssssss sssss

sdfsdfsdfsdfsdf

執(zhí)行測試程序 輸出結(jié)果如下(正確輸出)

  [root@linux]$ sh test.sh

sdfsdfsdfsdf

ssssss ssssss ssssss sssss

sdfsdfsdfsdfsdf

如果未設(shè)置IFS變量,使用默認的IFS變量值 ,輸出結(jié)果如下

  [root@linux]$ sh test.sh

sdfsdfsdfsdf

ssssss

ssssss

ssssss

sssss

sdfsdfsdfsdfsdf

從以上測試程序輸出結(jié)果,可以根據(jù)自己的需求來設(shè)定 IFS變量,在舉一個例子如下:

  while IFS=: read userName passWord userID groupID geCos homeDir userShell

do

echo "$userName -> $homeDir"

done < /etc/passwd

7. shell 數(shù)組的使用

數(shù)組賦值方式:

  (1) array=(var1 var2 var3 ... varN)

(2) array=([0]=var1 [1]=var2 [2]=var3 ... [n]=varN)

(3) array[0]=var1

arrya[1]=var2

...

array[n]=varN

計算數(shù)組元素個數(shù)或者長度:

  (1) ${#array[@]}

(2) ${#array[*]}

了解了數(shù)組基礎(chǔ)語法，舉例說明，請看:

  #!/bin/bash

NAMESERVERS=("ns1.www.net." "ns2.www.net." "ns3.www.net.")

# 得到數(shù)組長度

tLen=${#NAMESERVERS[@]}



# 循環(huán)數(shù)組

for (( i=0; i<${tLen}; i++ ));

do

echo ${NAMESERVERS[$i]}

done

在看一個復(fù)雜一點的例子,將文件內(nèi)容讀取到數(shù)組中:

  #!/bin/bash



# 設(shè)置IFS將分割符 設(shè)置為 換行符("n)

OLDIFS=$IFS

IFS=$'"n' 



# 讀取文件內(nèi)容到數(shù)組

fileArray=($(cat file.txt))



# restore it

IFS=$OLDIFS

tLen=${#fileArray[@]}



# 循環(huán)顯示文件內(nèi)容

for (( i=0; i<${tLen}; i++ ));

do

echo "${fileArray[$i]}"

done

8. 邏輯判斷 條件測試

• 文件屬性的判斷

舉例如下,測試文件是否存在:

  #!/bin/bash

echo "checks the existence of the messages file."

echo -n "Checking..."

if [ -f /var/log/messages ];then

echo "/var/log/messages exists."

fi

echo

echo "...done."

• 字符串比較

舉例如下,比較字符串來測試用戶ID :

  if [ "$(whoami)" != 'root' ]; then

echo "You have no permission to run $0 as non-root user."

exit 1;

fi

• 數(shù)值比較(整數(shù))

舉例如下:

  num=`wc -l work.txt`

if [ $num -gt 150 ];then

echo "you've worked hard enough for today."

echo

fi

如果要查看詳細的測試操作,可以查看man手冊 man test

Ctrl-E 相當于End鍵，即將光標移動到本行末尾

Ctrl-B 相當于左箭頭鍵，用于將光標向左移動一格

Ctrl-F 相當于右箭頭鍵，用于將光標向右移動一格

Ctrl-D 相當于Del鍵，即刪除光標所在處的字符

Ctrl-K 用于刪除從光標處開始到結(jié)尾處的所有字符

Ctrl-L 清屏，相當于clear命令

Ctrl-R 進入歷史命令查找狀態(tài)，然后你輸入幾個關(guān)鍵字符，就可以找到你使用過的命令

Ctrl-U 用于刪除從光標開始到行首的所有字符。一般在密碼或命令輸入錯誤時常用

Ctrl-H 刪除光標左側(cè)的一個字符

Ctrl-W 用于刪除當前光標左側(cè)的一個單詞

Ctrl-P 相當于上箭頭鍵，即顯示上一個命令

Ctrl-N 相當于下箭頭鍵，即顯示下一個命令

Ctrl-T 用于顛倒光標所在處字符和前一個字符的位置。（目前不知道有什么作用，哪位朋友知道？）

Ctrl-J 相當于回車鍵

                    
        最底層使用伙伴算法管理內(nèi)存頁面。系統(tǒng)將所有空閑內(nèi)存頁面分10個組，每個組中的內(nèi)存塊大小依次是1，2，4……512個內(nèi)存頁面，每組中的內(nèi)存塊大小相 同，并且以鏈表結(jié)構(gòu)保存。大小相同，并且內(nèi)存地址連續(xù)的兩個內(nèi)存塊稱為伙伴?；锇樗惴ǖ闹行乃枷刖褪菍⒊蔀榛锇榈目臻e內(nèi)存合并成一個更大的內(nèi)存塊。
        os中使用get_free_page獲取空閑頁面，如果找不到合適大小的空閑頁面，則從更大的組中找到空閑內(nèi)存塊，分配出去，并將剩余內(nèi)存分割，插入到 合適的組中。當歸還內(nèi)存時，啟動伙伴算法合并空閑內(nèi)存。如果不停的申請內(nèi)存，并且部分歸還，但歸還的內(nèi)存不能成為伙伴，長期運行后，所有內(nèi)存將被分割成不 相鄰的小塊，當再次申請大塊內(nèi)存時，則可能由于找不到足夠大的連續(xù)內(nèi)存塊而失敗，這種零散的不相鄰的小塊內(nèi)存稱之為內(nèi)存碎片。當然這只是理論上的說明，伙 伴算法本身就是為了解決內(nèi)存碎片問題。

二  malloc子系統(tǒng)內(nèi)存管理（dlmalloc)
        應(yīng)用層面的開發(fā)并不是直接調(diào)用sbrk/mmap之類的函數(shù)，而是調(diào)用malloc/free等malloc子系統(tǒng)提供的函數(shù)，linux上安裝的大多為 DougLea的dlmalloc或者其變形ptmalloc。下面以dlmalloc為例說明malloc工作的原理。
1 dlmalloc下名詞解釋：
   boundary tag: 邊界標記，每個空閑內(nèi)存塊均有頭部表識和尾部標識，尾部表識的作為是合并空閑內(nèi)存塊時更快。這部分空間屬于無法被應(yīng)用層面使用浪費的內(nèi)存空間。
   smallbins: 小內(nèi)存箱。dlmalloc將8,16,24……512大小的內(nèi)存分箱，相臨箱子中的內(nèi)存相差8字節(jié)。每個箱子中的內(nèi)存大小均相同，并且以雙向鏈表連接。
   treebins: 樹結(jié)構(gòu)箱。大于512字節(jié)的內(nèi)存不再是每8字節(jié)1箱，而是一個范圍段一箱。比如512~640, 640~896…..每個箱子的范圍段依次是128，256，512……。每箱中的結(jié)構(gòu)不再是雙向鏈表，而是樹形結(jié)構(gòu)。
   dv chunk:  當申請內(nèi)存而在對應(yīng)大小的箱中找不到大小合適的內(nèi)存，則從更大的箱中找一塊內(nèi)存，劃分出需要的內(nèi)存，剩余的內(nèi)存稱之為dv chunk.
   top chunk: 當dlmalloc中管理的內(nèi)存都找不到合適的內(nèi)存時，則調(diào)用sbrk從系統(tǒng)申請內(nèi)存，可以增長內(nèi)存方向的chunk稱為top chunk.
2 內(nèi)存分配算法
        從合適的箱子中尋找內(nèi)存塊–>從相臨的箱子中尋找內(nèi)存塊–>從dv chunk分配內(nèi)存–>從其他可行的箱子中分配內(nèi)存–>從top chunk中分配內(nèi)存–>調(diào)用sbrk/mmap申請內(nèi)存
3 內(nèi)存釋放算法
       臨近內(nèi)存合并–>如屬于top chunk，判斷top chunk>128k，是則歸還系統(tǒng)
                              –>不屬于chunk，則歸相應(yīng)的箱子

摘要：介紹了一個簡單的字符設(shè)備驅(qū)動程序，深入剖析了write函數(shù)的工作原理

     在Linux下我們在使用設(shè)備的時候，都會用到write這個函數(shù)，通過這個函數(shù)我們可以象使

用文件那樣向設(shè)備傳送數(shù)據(jù)。可是為什么用戶使用write函數(shù)就可以把數(shù)據(jù)寫到設(shè)備里面

去，這個過程到底是怎么實現(xiàn)的呢？ 



這個奧秘就在于設(shè)備驅(qū)動程序的write實現(xiàn)中，這里我結(jié)合一些源代碼來解釋如何使得一

個簡簡單單的write函數(shù)能夠完成向設(shè)備里面寫數(shù)據(jù)的復(fù)雜過程。



這里的源代碼主要來自兩個地方。第一是oreilly出版的《Linux device driver》中的

實例，第二是Linux Kernel 2.2.14核心源代碼。我只列出了其中相關(guān)部分的內(nèi)容，如果

讀者有興趣，也可以查閱其它源代碼。不過我不是在講解如何編寫設(shè)備驅(qū)動程序，所以不

會對每一個細節(jié)都進行說明，再說有些地方我覺得自己還沒有吃透。



由于《Linux device driver》一書中的例子對于我們還是復(fù)雜了一些，我將其中的一個

例程簡化了一下。這個驅(qū)動程序支持這樣一個設(shè)備：核心空間中的一個長度為10的數(shù)組

kbuf[10]。我們可以通過用戶程序open它，read它，write它，close它。這個設(shè)備的名

字我稱為short_t。 



現(xiàn)在言歸正傳。 

對于一個設(shè)備，它可以在/dev下面存在一個對應(yīng)的邏輯設(shè)備節(jié)點，這個節(jié)點以文件的形式

存在，但它不是普通意義上的文件，它是設(shè)備文件，更確切的說，它是設(shè)備節(jié)點。這個節(jié)

點是通過mknod命令建立的，其中指定了主設(shè)備號和次設(shè)備號。主設(shè)備號表明了某一類設(shè)

備，一般對應(yīng)著確定的驅(qū)動程序；次設(shè)備號一般是區(qū)分是標明不同屬性，例如不同的使用

方法，不同的位置，不同的操作。這個設(shè)備號是從/proc/devices文件中獲得的，所以一

般是先有驅(qū)動程序在內(nèi)核中，才有設(shè)備節(jié)點在目錄中。這個設(shè)備號（特指主設(shè)備號）的主

要作用，就是聲明設(shè)備所使用的驅(qū)動程序。驅(qū)動程序和設(shè)備號是一一對應(yīng)的，當你打開一

個設(shè)備文件時，操作系統(tǒng)就已經(jīng)知道這個設(shè)備所對應(yīng)的驅(qū)動程序是哪一個了。這個"知道"

的過程后面就講。 



我們再說說驅(qū)動程序的基本結(jié)構(gòu)吧。這里我只介紹動態(tài)模塊型驅(qū)動程序（就是我們使用

insmod加載到核心中并使用rmmod卸載的那種），因為我只熟悉這種結(jié)構(gòu)。 

模塊化的驅(qū)動程序由兩個函數(shù)是固定的：int init_module(void) ；void

cleanup_module(void)。前者在insmod的時候執(zhí)行，后者在rmmod的時候執(zhí)行。 

init_nodule在執(zhí)行的時候，進行一些驅(qū)動程序初始化的工作，其中最主要的工作有三

件：注冊設(shè)備；申請I/O端口地址范圍；申請中斷IRQ。這里和我們想知道的事情相關(guān)的只

有注冊設(shè)備。



下面是一個典型的init_module函數(shù)： 



int init_module(void){ 

int result = check_region(short_base,1)；/* 察看端口地址*/ 

…… 

request_region(short_base,1,"short"); /* 申請端口地址*/ 

…… 

result = register_chrdev(short_major, "short", &short_fops); /* 注冊設(shè)備

*/ 

…… 

result = request_irq(short_irq, short_interrupt, SA_INTERRUPT, "short",

NULL); /* 申請IRQ */ 

…… 

return 0; 

}/* init_module*/ 



上面這個函數(shù)我只保留了最重要的部分，其中最重要的函數(shù)是 

result = register_chrdev(short_major, "short", &short_fops); 

這是一個驅(qū)動程序的精髓所在！！當你執(zhí)行indmod命令時，這個函數(shù)可以完成三件大事：

第一，申請主設(shè)備號(short_major)，或者指定，或者動態(tài)分配；第二，在內(nèi)核中注冊設(shè)

備的名字("short")；第三，指定fops方法(&short_fops)。其中所指定的fops方法就是

我們對設(shè)備進行操作的方法（例如read,write,seek,dir,open,release等），如何實現(xiàn)

這些方法，是編寫設(shè)備驅(qū)動程序大部分工作量所在。 



現(xiàn)在我們就要接觸關(guān)鍵部分了--如何實現(xiàn)fops方法。 

我們都知道，每一個文件都有一個file的結(jié)構(gòu)，在這個結(jié)構(gòu)中有一個file_operations的

結(jié)構(gòu)體，這個結(jié)構(gòu)體指明了能夠?qū)υ撐募M行的操作。



下面是一個典型的file_operations結(jié)構(gòu)： 

struct file_operations { 

loff_t (*llseek) (struct file *, loff_t, int); 

ssize_t (*read) (struct file *, char *, size_t, loff_t *); 

ssize_t (*write) (struct file *, const char *, size_t, loff_t *); 

int (*readdir) (struct file *, void *, filldir_t); 

unsigned int (*poll) (struct file *, struct poll_table_struct *); 

int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned

long); 

int (*mmap) (struct file *, struct vm_area_struct *); 

int (*open) (struct inode *, struct file *); 

int (*flush) (struct file *); 

int (*release) (struct inode *, struct file *); 

int (*fsync) (struct file *, struct dentry *); 

int (*fasync) (int, struct file *, int); 

int (*check_media_change) (kdev_t dev); 

int (*revalidate) (kdev_t dev); 

int (*lock) (struct file *, int, struct file_lock *); 

}; 



我們可以看到它實際上就是許多文件操作的函數(shù)指針，其中就有write，其它的我們就不

去管它了。這個write指針在實際的驅(qū)動程序中會以程序員所實現(xiàn)的函數(shù)名字出現(xiàn)，它指

向程序員實現(xiàn)的設(shè)備write操作函數(shù)。下面就是一個實際的例子，這個write函數(shù)可以向核

心內(nèi)存的一個數(shù)組里輸入一個字符串。 



int short_write (struct inode *inode, struct file *filp, const char *buf,

int count){ 

int retval = count; 

extern unsigned char kbuf[10]; 



if(count>10) 

count=10; 

copy_from_user(kbuf, buf, count); 

return retval; 

}/* short_write */ 

設(shè)備short_t對應(yīng)的fops方法是這樣聲明的： 

struct file_operations short_fops = { 

NULL, /* short_lseek */ 

short_read, 

short_write, 

NULL, /* short_readdir */ 

NULL, /* short_poll */ 

NULL, /* short_ioctl */ 

NULL, /* short_mmap */ 

short_open, 

short_release, 

NULL, /* short_fsync */ 

NULL, /* short_fasync */ 

/* nothing more, fill with NULLs */ 

}; 



其中NULL的項目就是不提供這個功能。所以我們可以看出short_t設(shè)備只提供了

read,write,open,release功能。其中write功能我們在上面已經(jīng)實現(xiàn)了，具體的實現(xiàn)函

數(shù)起名為short_write。這些函數(shù)就是真正對設(shè)備進行操作的函數(shù)，這就是驅(qū)動程序的一

大好處：不管你實現(xiàn)的時候是多么的復(fù)雜，但對用戶來看，就是那些常用的文件操作函數(shù)。



但是我們可以看到，驅(qū)動程序里的write函數(shù)有四個參數(shù)，函數(shù)格式如下： 

short_write (struct inode *inode, struct file *filp, const char *buf, int count) 

而用戶程序中的write函數(shù)只有三個參數(shù)，函數(shù)格式如下： 

write(inf fd, char *buf, int count) 

那他們兩個是怎么聯(lián)系在一起的呢？這就要靠操作系統(tǒng)核心中的函數(shù)sys_write了，下面

是Linux Kernel 2.2.14中sys_write中的源代碼： 

asmlinkage ssize_t sys_write(unsigned int fd, const char * buf, size_t count) 

{ 

ssize_t ret; 

struct file * file; 

struct inode * inode; 

ssize_t (*write)(struct file *, const char *, size_t, loff_t *); /* 指向

驅(qū)動程序中的wirte函數(shù)的指針*/ 



lock_kernel(); 

ret = -EBADF; 

file = fget(fd); /* 通過文件描述符得到文件指針 */ 

if (!file) 

goto bad_file; 

if (!(file->f_mode & FMODE_WRITE)) 

goto out; 

inode = file->f_dentry->d_inode; /* 得到inode信息 */ 

ret = locks_verify_area(FLOCK_VERIFY_WRITE, inode, file, file->f_pos,

count); 

if (ret) 

goto out; 

ret = -EINVAL; 

if (!file->f_op || !(write = file->f_op->write)) /* 將函數(shù)開始時聲明的

write函數(shù)指針指向fops方法中對應(yīng)的write函數(shù) */ 

goto out; 

down(&inode->i_sem); 

ret = write(file, buf, count, &file->f_pos); /* 使用驅(qū)動程序中的write函數(shù)

將數(shù)據(jù)輸入設(shè)備，注意看，這里就是四個參數(shù)了 */ 

up(&inode->i_sem); 

out: 

fput(file); 

bad_file: 

unlock_kernel(); 

return ret; 

} 



我寫了一個簡單的程序來測試這個驅(qū)動程序，該程序源代碼節(jié)選如下（該省的我都省了）： 



main(){ 

int fd,count=0; 

unsigned char buf[10]; 

fd=open("/dev/short_t",O_RDWR); 

printf("input string:"); 

scanf("%s",buf); 

count=strlen(buf); 

if(count>10) 

count=10; 

count=write(fd,buf,count); 

close(fd); 

return 1; 

} 



現(xiàn)在我們就演示一下用戶使用write函數(shù)將數(shù)據(jù)寫到設(shè)備里面這個過程到底是怎么實現(xiàn)的： 

1，insmod驅(qū)動程序。驅(qū)動程序申請設(shè)備名和主設(shè)備號，這些可以在/proc/devieces中獲得。 

2，從/proc/devices中獲得主設(shè)備號，并使用mknod命令建立設(shè)備節(jié)點文件。這是通過主

設(shè)備號將設(shè)備節(jié)點文件和設(shè)備驅(qū)動程序聯(lián)系在一起。設(shè)備節(jié)點文件中的file屬性中指明了

驅(qū)動程序中fops方法實現(xiàn)的函數(shù)指針。 

3，用戶程序使用open打開設(shè)備節(jié)點文件，這時操作系統(tǒng)內(nèi)核知道該驅(qū)動程序工作了，就

調(diào)用fops方法中的open函數(shù)進行相應(yīng)的工作。open方法一般返回的是文件標示符，實際

上并不是直接對它進行操作的，而是有操作系統(tǒng)的系統(tǒng)調(diào)用在背后工作。 

4，當用戶使用write函數(shù)操作設(shè)備文件時，操作系統(tǒng)調(diào)用sys_write函數(shù)，該函數(shù)首先通

過文件標示符得到設(shè)備節(jié)點文件對應(yīng)的inode指針和flip指針。inode指針中有設(shè)備號信

息，能夠告訴操作系統(tǒng)應(yīng)該使用哪一個設(shè)備驅(qū)動程序，flip指針中有fops信息，可以告訴

操作系統(tǒng)相應(yīng)的fops方法函數(shù)在那里可以找到。 

5，然后這時sys_write才會調(diào)用驅(qū)動程序中的write方法來對設(shè)備進行寫的操作。 

其中1-3都是在用戶空間進行的，4-5是在核心空間進行的。用戶的write函數(shù)和操作系統(tǒng)

的write函數(shù)通過系統(tǒng)調(diào)用sys_write聯(lián)系在了一起。 

注意： 

對于塊設(shè)備來說，還存在寫的模式的問題，這應(yīng)該是由GNU C庫來解決的，這里不予討

論，因為我沒有看過GNU C庫的源代碼。 

另外，這是一個測試版的文章，請各位朋友們多提意見和建議，非常感謝！ 

http://blog.csdn.net/lphpc/category/170686.aspx

1. 在嵌入式系統(tǒng)中，有時core dump直接從串口打印出來，結(jié)合objdump查找ra和epa地址，運用棧回溯，可以找到程序出錯的地方。

2. 在一般Linux系統(tǒng)中，默認是不會產(chǎn)生core dump文件的，通過ulimit -c來查看core dump文件的大小，一般開始是0，可以設(shè)置core文件大小，ulimit -c 1024(kbytes單位)或者ulimit -c unlimited。

3. core dump文件輸出設(shè)置，一般默認是當前目錄，可以在/proc/sys/kernel中找到core-user-pid，通過

echo "1" > /proc/sys/kernel/core-user-pid使core文件名加上pid號，還可以用

mkdir -p /root/corefile

echo "/root/corefile/core-%e-%p-%t" > /proc/sys/kernel/core-pattern控制core文件保存位置和文件名格式。

以下是參數(shù)列表:
    %p - insert pid into filename 添加pid
    %u - insert current uid into filename 添加當前uid
    %g - insert current gid into filename 添加當前gid
    %s - insert signal that caused the coredump into the filename 添加導(dǎo)致產(chǎn)生core的信號
    %t - insert UNIX time that the coredump occurred into filename 添加core文件生成時的unix時間
    %h - insert hostname where the coredump happened into filename 添加主機名
    %e - insert coredumping executable name into filename 添加命令名


4. 用gdb查看core文件:
下面我們可以在發(fā)生運行時信號引起的錯誤時發(fā)生core dump了.編譯時加上-g
發(fā)生core dump之后, 用gdb進行查看core文件的內(nèi)容, 以定位文件中引發(fā)core dump的行.
gdb [exec file] [core file]
如:
gdb ./test test.core
在進入gdb后, 用bt命令查看backtrace以檢查發(fā)生程序運行到哪里, 來定位core dump的文件行.

5. 給個例子

test.c

void a()

{

   char *p = NULL;

   printf("%d\n", *p);

}

int main()

{

    a();

    return 0;

}

編譯 gcc -g -o test test.c

運行 ./test

報segmentation fault(core dump)

gdb ./test test.core如果生成的是test.core.

本文來自CSDN博客，轉(zhuǎn)載請標明出處：http://blog.csdn.net/shanxiao528/archive/2010/05/11/5578743.aspx

共享內(nèi)存 最快的IPC之一
消息隊列
信號量 不同進程間 同一進程不同線程間的同步

Socket 不同機器上的進程間的通信

添加系統(tǒng)調(diào)用
添加系統(tǒng)模塊

內(nèi)存模型 分段 分頁
邏輯地址->線性地址->物理地址

所有的段寄存器 段內(nèi)偏移一樣

頁目錄 頁面 進程私有的
虛擬地址描述符表 虛擬內(nèi)存管理 分配回收

物理內(nèi)存管理

-----
進程
棧
堆
BSS
初始化的數(shù)據(jù)段
代碼段

內(nèi)核棧
控制塊

進程Entry：
進程的虛擬地址空間->分區(qū)->分頁
全局頁目錄pgd->pmd->page

線程同步
互斥鎖
pthread_mutex_t
pthread_mutex_initializer
pthread-mutex_int
pthread_mutex_lock
pthread_mutex_unlock

條件變量
pthread_cond_t
pthread_cond_init
ptread_con_wait
調(diào)用之前和調(diào)用之后都是上鎖的，一個條件變量關(guān)聯(lián)一個互斥鎖
函數(shù)內(nèi)部實現(xiàn)機制
解鎖
睡眠
上鎖
pthead_cond_destroy
pthread_cond_broadcast
pthead_cond_signalh

所用軟件：
VMware-workstation-6.0.0-45731.exe
Red Hat Linux 9

安裝過程：
1.安裝VMware-workstation-6.0.0-45731.exe
2.開啟VMware.安裝Linux.
  安裝時可直接用硬盤iso文件.
  VMware=>VM=>Settings=>CD-RoM=>Use ISO image(選擇iso位置,安裝一張,在換另一個iso文件)
3.安裝VMware后,會在XP上自動安裝2個虛擬網(wǎng)卡:
  VMware Virtual Ethernet Adapter for VMnet1
  VMware Virtual Ethernet Adapter for VMnet8
  XP運行cmd=>ipconfig/all
  會查看到2個虛擬網(wǎng)卡及真實網(wǎng)卡的IP配置.
  因這2個虛擬網(wǎng)卡是裝在XP系統(tǒng)上的，所以XP上可以Ping通.
4.此外,虛擬機上的Linux也有1個虛擬網(wǎng)卡,它的配置文件為
  /etc/sysconfig/network-scrīpts/ifcfg-eth0
5.我們可以把Linux的網(wǎng)關(guān)設(shè)置為XP系統(tǒng)虛擬網(wǎng)卡的IP地址,
  這樣Linux就可以和XP通信了.
6.VMware=>VM=>Settings=>Ethemet=>Custom:Specific virtual network 選VMnet1(Host-only)
  將VMware Virtual Ethernet Adapter for VMnet1地址
  設(shè)置為: 192.168.0.1
          255.255.255.0
  修改ifcfg-eth0文件如下:
  DEVICE=eth0
  ōNBOOT=yes
  BOOTPROTO=none
  IPADDR=192.168.0.2
  NETMASK=255.255.255.0
  GATEWAY=192.168.0.1
  TYPE=Ethernet
  USERCTL=no
  PEERDNS=no
  NETWORK=192.168.0.0
  BROADCAST=192.168.0.255
  保存后更新下# service network restart

  也可以打開Linux開始=>系統(tǒng)設(shè)置=>網(wǎng)絡(luò),進行設(shè)置.
7.這時XP和Linux可以通信了.
  XP運行:ping 192.168.0.2  OK
8.此外SecureCRT是個不錯的終端訪問軟件.可以裝在XP上，訪問Linux.
9.如果想讓虛擬機的Linux也上網(wǎng)的話.
  可以在XP=>本地連接屬性=>高級=>允許其他網(wǎng)絡(luò)用戶通過此計算機的Internet連接來連接
  (在家庭網(wǎng)絡(luò)連接中選擇VMware Network Adapter VMnet1)
  linux 主DNS 192.168.0.1

  這樣就可以在虛擬Linux上網(wǎng)了. 

AIO 簡介

Linux 異步 I/O 是 Linux 內(nèi)核中提供的一個相當新的增強。它是 2.6 版本內(nèi)核的一個標準特性，但是我們在 2.4 版本內(nèi)核的補丁中也可以找到它。AIO 背后的基本思想是允許進程發(fā)起很多 I/O 操作，而不用阻塞或等待任何操作完成。稍后或在接收到 I/O 操作完成的通知時，進程就可以檢索 I/O 操作的結(jié)果。

I/O 模型

在深入介紹 AIO API 之前，讓我們先來探索一下 Linux 上可以使用的不同 I/O 模型。這并不是一個詳盡的介紹，但是我們將試圖介紹最常用的一些模型來解釋它們與異步 I/O 之間的區(qū)別。圖 1 給出了同步和異步模型，以及阻塞和非阻塞的模型。

每個 I/O 模型都有自己的使用模式，它們對于特定的應(yīng)用程序都有自己的優(yōu)點。本節(jié)將簡要對其一一進行介紹。

同步阻塞 I/O

I/O 密集型與 CPU 密集型進程的比較 I/O 密集型進程所執(zhí)行的 I/O 操作比執(zhí)行的處理操作更多。CPU 密集型的進程所執(zhí)行的處理操作比 I/O 操作更多。Linux 2.6 的調(diào)度器實際上更加偏愛 I/O 密集型的進程，因為它們通常會發(fā)起一個 I/O 操作，然后進行阻塞，這就意味著其他工作都可以在兩者之間有效地交錯進行。

最常用的一個模型是同步阻塞 I/O 模型。在這個模型中，用戶空間的應(yīng)用程序執(zhí)行一個系統(tǒng)調(diào)用，這會導(dǎo)致應(yīng)用程序阻塞。這意味著應(yīng)用程序會一直阻塞，直到系統(tǒng)調(diào)用完成為止（數(shù)據(jù)傳輸完成或發(fā)生錯誤）。調(diào)用應(yīng)用程序處于一種不再消費 CPU 而只是簡單等待響應(yīng)的狀態(tài)，因此從處理的角度來看，這是非常有效的。

圖 2 給出了傳統(tǒng)的阻塞 I/O 模型，這也是目前應(yīng)用程序中最為常用的一種模型。其行為非常容易理解，其用法對于典型的應(yīng)用程序來說都非常有效。在調(diào)用 read 系統(tǒng)調(diào)用時，應(yīng)用程序會阻塞并對內(nèi)核進行上下文切換。然后會觸發(fā)讀操作，當響應(yīng)返回時（從我們正在從中讀取的設(shè)備中返回），數(shù)據(jù)就被移動到用戶空間的緩沖區(qū)中。然后應(yīng)用程序就會解除阻塞（read 調(diào)用返回）。

從應(yīng)用程序的角度來說，read 調(diào)用會延續(xù)很長時間。實際上，在內(nèi)核執(zhí)行讀操作和其他工作時，應(yīng)用程序的確會被阻塞。

同步非阻塞 I/O

同步阻塞 I/O 的一種效率稍低的變種是同步非阻塞 I/O。在這種模型中，設(shè)備是以非阻塞的形式打開的。這意味著 I/O 操作不會立即完成，read 操作可能會返回一個錯誤代碼，說明這個命令不能立即滿足（EAGAIN 或 EWOULDBLOCK），如圖 3 所示。

非阻塞的實現(xiàn)是 I/O 命令可能并不會立即滿足，需要應(yīng)用程序調(diào)用許多次來等待操作完成。這可能效率不高，因為在很多情況下，當內(nèi)核執(zhí)行這個命令時，應(yīng)用程序必須要進行忙碌等待，直到數(shù)據(jù)可用為止，或者試圖執(zhí)行其他工作。正如圖 3 所示的一樣，這個方法可以引入 I/O 操作的延時，因為數(shù)據(jù)在內(nèi)核中變?yōu)榭捎玫接脩粽{(diào)用 read 返回數(shù)據(jù)之間存在一定的間隔，這會導(dǎo)致整體數(shù)據(jù)吞吐量的降低。

異步阻塞 I/O

另外一個阻塞解決方案是帶有阻塞通知的非阻塞 I/O。在這種模型中，配置的是非阻塞 I/O，然后使用阻塞 select 系統(tǒng)調(diào)用來確定一個 I/O 描述符何時有操作。使 select 調(diào)用非常有趣的是它可以用來為多個描述符提供通知，而不僅僅為一個描述符提供通知。對于每個提示符來說，我們可以請求這個描述符可以寫數(shù)據(jù)、有讀數(shù)據(jù)可用以及是否發(fā)生錯誤的通知。

select 調(diào)用的主要問題是它的效率不是非常高。盡管這是異步通知使用的一種方便模型，但是對于高性能的 I/O 操作來說不建議使用。

異步非阻塞 I/O（AIO）

最后，異步非阻塞 I/O 模型是一種處理與 I/O 重疊進行的模型。讀請求會立即返回，說明 read 請求已經(jīng)成功發(fā)起了。在后臺完成讀操作時，應(yīng)用程序然后會執(zhí)行其他處理操作。當 read 的響應(yīng)到達時，就會產(chǎn)生一個信號或執(zhí)行一個基于線程的回調(diào)函數(shù)來完成這次 I/O 處理過程。

在一個進程中為了執(zhí)行多個 I/O 請求而對計算操作和 I/O 處理進行重疊處理的能力利用了處理速度與 I/O 速度之間的差異。當一個或多個 I/O 請求掛起時，CPU 可以執(zhí)行其他任務(wù)；或者更為常見的是，在發(fā)起其他 I/O 的同時對已經(jīng)完成的 I/O 進行操作。

下一節(jié)將深入介紹這種模型，探索這種模型使用的 API，然后展示幾個命令。

回頁首

異步 I/O 的動機

從前面 I/O 模型的分類中，我們可以看出 AIO 的動機。這種阻塞模型需要在 I/O 操作開始時阻塞應(yīng)用程序。這意味著不可能同時重疊進行處理和 I/O 操作。同步非阻塞模型允許處理和 I/O 操作重疊進行，但是這需要應(yīng)用程序根據(jù)重現(xiàn)的規(guī)則來檢查 I/O 操作的狀態(tài)。這樣就剩下異步非阻塞 I/O 了，它允許處理和 I/O 操作重疊進行，包括 I/O 操作完成的通知。

除了需要阻塞之外，select 函數(shù)所提供的功能（異步阻塞 I/O）與 AIO 類似。不過，它是對通知事件進行阻塞，而不是對 I/O 調(diào)用進行阻塞。

回頁首

Linux 上的 AIO 簡介

本節(jié)將探索 Linux 的異步 I/O 模型，從而幫助我們理解如何在應(yīng)用程序中使用這種技術(shù)。

在傳統(tǒng)的 I/O 模型中，有一個使用惟一句柄標識的 I/O 通道。在 UNIX® 中，這些句柄是文件描述符（這對等同于文件、管道、套接字等等）。在阻塞 I/O 中，我們發(fā)起了一次傳輸操作，當傳輸操作完成或發(fā)生錯誤時，系統(tǒng)調(diào)用就會返回。

Linux 上的 AIO AIO 在 2.5 版本的內(nèi)核中首次出現(xiàn)，現(xiàn)在已經(jīng)是 2.6 版本的產(chǎn)品內(nèi)核的一個標準特性了。

在異步非阻塞 I/O 中，我們可以同時發(fā)起多個傳輸操作。這需要每個傳輸操作都有惟一的上下文，這樣我們才能在它們完成時區(qū)分到底是哪個傳輸操作完成了。在 AIO 中，這是一個 aiocb（AIO I/O Control Block）結(jié)構(gòu)。這個結(jié)構(gòu)包含了有關(guān)傳輸?shù)乃行畔ⅲ閿?shù)據(jù)準備的用戶緩沖區(qū)。在產(chǎn)生 I/O （稱為完成）通知時，aiocb 結(jié)構(gòu)就被用來惟一標識所完成的 I/O 操作。這個 API 的展示顯示了如何使用它。

回頁首

AIO API

AIO 接口的 API 非常簡單，但是它為數(shù)據(jù)傳輸提供了必需的功能，并給出了兩個不同的通知模型。表 1 給出了 AIO 的接口函數(shù)，本節(jié)稍后會更詳細進行介紹。

每個 API 函數(shù)都使用 aiocb 結(jié)構(gòu)開始或檢查。這個結(jié)構(gòu)有很多元素，但是清單 1 僅僅給出了需要（或可以）使用的元素。

            struct aiocb {
            int aio_fildes;               // File Descriptor
            int aio_lio_opcode;           // Valid only for lio_listio (r/w/nop)
            volatile void *aio_buf;       // Data Buffer
            size_t aio_nbytes;            // Number of Bytes in Data Buffer
            struct sigevent aio_sigevent; // Notification Structure
            /* Internal fields */
            ...
            };
            

sigevent 結(jié)構(gòu)告訴 AIO 在 I/O 操作完成時應(yīng)該執(zhí)行什么操作。我們將在 AIO 的展示中對這個結(jié)構(gòu)進行探索。現(xiàn)在我們將展示各個 AIO 的 API 函數(shù)是如何工作的，以及我們應(yīng)該如何使用它們。

aio_read

aio_read 函數(shù)請求對一個有效的文件描述符進行異步讀操作。這個文件描述符可以表示一個文件、套接字甚至管道。aio_read 函數(shù)的原型如下：

int aio_read( struct aiocb *aiocbp );
            

aio_read 函數(shù)在請求進行排隊之后會立即返回。如果執(zhí)行成功，返回值就為 0；如果出現(xiàn)錯誤，返回值就為 -1，并設(shè)置 errno 的值。

要執(zhí)行讀操作，應(yīng)用程序必須對 aiocb 結(jié)構(gòu)進行初始化。下面這個簡短的例子就展示了如何填充 aiocb 請求結(jié)構(gòu)，并使用 aio_read 來執(zhí)行異步讀請求（現(xiàn)在暫時忽略通知）操作。它還展示了 aio_error 的用法，不過我們將稍后再作解釋。

            #include <aio.h>
            ...
            int fd, ret;
            struct aiocb my_aiocb;
            fd = open( "file.txt", O_RDONLY );
            if (fd < 0) perror("open");
            /* Zero out the aiocb structure (recommended) */
            bzero( (char *)&my_aiocb, sizeof(struct aiocb) );
            /* Allocate a data buffer for the aiocb request */
            my_aiocb.aio_buf = malloc(BUFSIZE+1);
            if (!my_aiocb.aio_buf) perror("malloc");
            /* Initialize the necessary fields in the aiocb */
            my_aiocb.aio_fildes = fd;
            my_aiocb.aio_nbytes = BUFSIZE;
            my_aiocb.aio_offset = 0;
            ret = aio_read( &my_aiocb );
            if (ret < 0) perror("aio_read");
            while ( aio_error( &my_aiocb ) == EINPROGRESS ) ;
            if ((ret = aio_return( &my_iocb )) > 0) {
            /* got ret bytes on the read */
            } else {
            /* read failed, consult errno */
            }
            

在清單 2 中，在打開要從中讀取數(shù)據(jù)的文件之后，我們就清空了 aiocb 結(jié)構(gòu)，然后分配一個數(shù)據(jù)緩沖區(qū)。并將對這個數(shù)據(jù)緩沖區(qū)的引用放到 aio_buf 中。然后，我們將 aio_nbytes 初始化成緩沖區(qū)的大小。并將 aio_offset 設(shè)置成 0（該文件中的第一個偏移量）。我們將 aio_fildes 設(shè)置為從中讀取數(shù)據(jù)的文件描述符。在設(shè)置這些域之后，就調(diào)用 aio_read 請求進行讀操作。我們?nèi)缓罂梢哉{(diào)用 aio_error 來確定 aio_read 的狀態(tài)。只要狀態(tài)是 EINPROGRESS，就一直忙碌等待，直到狀態(tài)發(fā)生變化為止。現(xiàn)在，請求可能成功，也可能失敗。

使用 AIO 接口來編譯程序 我們可以在 aio.h 頭文件中找到函數(shù)原型和其他需要的符號。在編譯使用這種接口的程序時，我們必須使用 POSIX 實時擴展庫（librt）。

注意使用這個 API 與標準的庫函數(shù)從文件中讀取內(nèi)容是非常相似的。除了 aio_read 的一些異步特性之外，另外一個區(qū)別是讀操作偏移量的設(shè)置。在傳統(tǒng)的 read 調(diào)用中，偏移量是在文件描述符上下文中進行維護的。對于每個讀操作來說，偏移量都需要進行更新，這樣后續(xù)的讀操作才能對下一塊數(shù)據(jù)進行尋址。對于異步 I/O 操作來說這是不可能的，因為我們可以同時執(zhí)行很多讀請求，因此必須為每個特定的讀請求都指定偏移量。

aio_error

aio_error 函數(shù)被用來確定請求的狀態(tài)。其原型如下：

int aio_error( struct aiocb *aiocbp );
            

這個函數(shù)可以返回以下內(nèi)容：

• EINPROGRESS，說明請求尚未完成
• ECANCELLED，說明請求被應(yīng)用程序取消了
• -1，說明發(fā)生了錯誤，具體錯誤原因可以查閱 errno

aio_return

異步 I/O 和標準塊 I/O 之間的另外一個區(qū)別是我們不能立即訪問這個函數(shù)的返回狀態(tài)，因為我們并沒有阻塞在 read 調(diào)用上。在標準的 read 調(diào)用中，返回狀態(tài)是在該函數(shù)返回時提供的。但是在異步 I/O 中，我們要使用 aio_return 函數(shù)。這個函數(shù)的原型如下：

ssize_t aio_return( struct aiocb *aiocbp );
            

只有在 aio_error 調(diào)用確定請求已經(jīng)完成（可能成功，也可能發(fā)生了錯誤）之后，才會調(diào)用這個函數(shù)。aio_return 的返回值就等價于同步情況中 read 或 write 系統(tǒng)調(diào)用的返回值（所傳輸?shù)淖止?jié)數(shù)，如果發(fā)生錯誤，返回值就為 -1）。

aio_write

aio_write 函數(shù)用來請求一個異步寫操作。其函數(shù)原型如下：

int aio_write( struct aiocb *aiocbp );
            

aio_write 函數(shù)會立即返回，說明請求已經(jīng)進行排隊（成功時返回值為 0，失敗時返回值為 -1，并相應(yīng)地設(shè)置 errno）。

這與 read 系統(tǒng)調(diào)用類似，但是有一點不一樣的行為需要注意。回想一下對于 read 調(diào)用來說，要使用的偏移量是非常重要的。然而，對于 write 來說，這個偏移量只有在沒有設(shè)置 O_APPEND 選項的文件上下文中才會非常重要。如果設(shè)置了 O_APPEND，那么這個偏移量就會被忽略，數(shù)據(jù)都會被附加到文件的末尾。否則，aio_offset 域就確定了數(shù)據(jù)在要寫入的文件中的偏移量。

aio_suspend

我們可以使用 aio_suspend 函數(shù)來掛起（或阻塞）調(diào)用進程，直到異步請求完成為止，此時會產(chǎn)生一個信號，或者發(fā)生其他超時操作。調(diào)用者提供了一個 aiocb 引用列表，其中任何一個完成都會導(dǎo)致 aio_suspend 返回。 aio_suspend 的函數(shù)原型如下：

int aio_suspend( const struct aiocb *const cblist[],
            int n, const struct timespec *timeout );
            

aio_suspend 的使用非常簡單。我們要提供一個 aiocb 引用列表。如果任何一個完成了，這個調(diào)用就會返回 0。否則就會返回 -1，說明發(fā)生了錯誤。請參看清單 3。

            struct aioct *cblist[MAX_LIST]
            /* Clear the list. */
            bzero( (char *)cblist, sizeof(cblist) );
            /* Load one or more references into the list */
            cblist[0] = &my_aiocb;
            ret = aio_read( &my_aiocb );
            ret = aio_suspend( cblist, MAX_LIST, NULL );
            

注意，aio_suspend 的第二個參數(shù)是 cblist 中元素的個數(shù)，而不是 aiocb 引用的個數(shù)。cblist 中任何 NULL 元素都會被 aio_suspend 忽略。

如果為 aio_suspend 提供了超時，而超時情況的確發(fā)生了，那么它就會返回 -1，errno 中會包含 EAGAIN。

aio_cancel

aio_cancel 函數(shù)允許我們?nèi)∠麑δ硞€文件描述符執(zhí)行的一個或所有 I/O 請求。其原型如下：

int aio_cancel( int fd, struct aiocb *aiocbp );
            

要取消一個請求，我們需要提供文件描述符和 aiocb 引用。如果這個請求被成功取消了，那么這個函數(shù)就會返回 AIO_CANCELED。如果請求完成了，這個函數(shù)就會返回 AIO_NOTCANCELED。

要取消對某個給定文件描述符的所有請求，我們需要提供這個文件的描述符，以及一個對 aiocbp 的 NULL 引用。如果所有的請求都取消了，這個函數(shù)就會返回 AIO_CANCELED；如果至少有一個請求沒有被取消，那么這個函數(shù)就會返回 AIO_NOT_CANCELED；如果沒有一個請求可以被取消，那么這個函數(shù)就會返回 AIO_ALLDONE。我們?nèi)缓罂梢允褂?aio_error 來驗證每個 AIO 請求。如果這個請求已經(jīng)被取消了，那么 aio_error 就會返回 -1，并且 errno 會被設(shè)置為 ECANCELED。

lio_listio

最后，AIO 提供了一種方法使用 lio_listio API 函數(shù)同時發(fā)起多個傳輸。這個函數(shù)非常重要，因為這意味著我們可以在一個系統(tǒng)調(diào)用（一次內(nèi)核上下文切換）中啟動大量的 I/O 操作。從性能的角度來看，這非常重要，因此值得我們花點時間探索一下。lio_listio API 函數(shù)的原型如下：

int lio_listio( int mode, struct aiocb *list[], int nent,
            struct sigevent *sig );
            

mode 參數(shù)可以是 LIO_WAIT 或 LIO_NOWAIT。LIO_WAIT 會阻塞這個調(diào)用，直到所有的 I/O 都完成為止。在操作進行排隊之后，LIO_NOWAIT 就會返回。list 是一個 aiocb 引用的列表，最大元素的個數(shù)是由 nent 定義的。注意 list 的元素可以為 NULL，lio_listio 會將其忽略。sigevent 引用定義了在所有 I/O 操作都完成時產(chǎn)生信號的方法。

對于 lio_listio 的請求與傳統(tǒng)的 read 或 write 請求在必須指定的操作方面稍有不同，如清單 4 所示。

            struct aiocb aiocb1, aiocb2;
            struct aiocb *list[MAX_LIST];
            ...
            /* Prepare the first aiocb */
            aiocb1.aio_fildes = fd;
            aiocb1.aio_buf = malloc( BUFSIZE+1 );
            aiocb1.aio_nbytes = BUFSIZE;
            aiocb1.aio_offset = next_offset;
            aiocb1.aio_lio_opcode = LIO_READ;
            ...
            bzero( (char *)list, sizeof(list) );
            list[0] = &aiocb1;
            list[1] = &aiocb2;
            ret = lio_listio( LIO_WAIT, list, MAX_LIST, NULL );
            

對于讀操作來說，aio_lio_opcode 域的值為 LIO_READ。對于寫操作來說，我們要使用 LIO_WRITE，不過 LIO_NOP 對于不執(zhí)行操作來說也是有效的。

回頁首

AIO 通知

現(xiàn)在我們已經(jīng)看過了可用的 AIO 函數(shù)，本節(jié)將深入介紹對異步通知可以使用的方法。我們將通過信號和函數(shù)回調(diào)來探索異步函數(shù)的通知機制。

使用信號進行異步通知

使用信號進行進程間通信（IPC）是 UNIX 中的一種傳統(tǒng)機制，AIO 也可以支持這種機制。在這種范例中，應(yīng)用程序需要定義信號處理程序，在產(chǎn)生指定的信號時就會調(diào)用這個處理程序。應(yīng)用程序然后配置一個異步請求將在請求完成時產(chǎn)生一個信號。作為信號上下文的一部分，特定的 aiocb 請求被提供用來記錄多個可能會出現(xiàn)的請求。清單 5 展示了這種通知方法。

            void setup_io( ... )
            {
            int fd;
            struct sigaction sig_act;
            struct aiocb my_aiocb;
            ...
            /* Set up the signal handler */
            sigemptyset(&sig_act.sa_mask);
            sig_act.sa_flags = SA_SIGINFO;
            sig_act.sa_sigaction = aio_completion_handler;
            /* Set up the AIO request */
            bzero( (char *)&my_aiocb, sizeof(struct aiocb) );
            my_aiocb.aio_fildes = fd;
            my_aiocb.aio_buf = malloc(BUF_SIZE+1);
            my_aiocb.aio_nbytes = BUF_SIZE;
            my_aiocb.aio_offset = next_offset;
            /* Link the AIO request with the Signal Handler */
            my_aiocb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
            my_aiocb.aio_sigevent.sigev_signo = SIGIO;
            my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb;
            /* Map the Signal to the Signal Handler */
            ret = sigaction( SIGIO, &sig_act, NULL );
            ...
            ret = aio_read( &my_aiocb );
            }
            void aio_completion_handler( int signo, siginfo_t *info, void *context )
            {
            struct aiocb *req;
            /* Ensure it's our signal */
            if (info->si_signo == SIGIO) {
            req = (struct aiocb *)info->si_value.sival_ptr;
            /* Did the request complete? */
            if (aio_error( req ) == 0) {
            /* Request completed successfully, get the return status */
            ret = aio_return( req );
            }
            }
            return;
            }
            

在清單 5 中，我們在 aio_completion_handler 函數(shù)中設(shè)置信號處理程序來捕獲 SIGIO 信號。然后初始化 aio_sigevent 結(jié)構(gòu)產(chǎn)生 SIGIO 信號來進行通知（這是通過 sigev_notify 中的 SIGEV_SIGNAL 定義來指定的）。當讀操作完成時，信號處理程序就從該信號的 si_value 結(jié)構(gòu)中提取出 aiocb，并檢查錯誤狀態(tài)和返回狀態(tài)來確定 I/O 操作是否完成。

對于性能來說，這個處理程序也是通過請求下一次異步傳輸而繼續(xù)進行 I/O 操作的理想地方。采用這種方式，在一次數(shù)據(jù)傳輸完成時，我們就可以立即開始下一次數(shù)據(jù)傳輸操作。

使用回調(diào)函數(shù)進行異步通知

另外一種通知方式是系統(tǒng)回調(diào)函數(shù)。這種機制不會為通知而產(chǎn)生一個信號，而是會調(diào)用用戶空間的一個函數(shù)來實現(xiàn)通知功能。我們在 sigevent 結(jié)構(gòu)中設(shè)置了對 aiocb 的引用，從而可以惟一標識正在完成的特定請求。請參看清單 6。

            void setup_io( ... )
            {
            int fd;
            struct aiocb my_aiocb;
            ...
            /* Set up the AIO request */
            bzero( (char *)&my_aiocb, sizeof(struct aiocb) );
            my_aiocb.aio_fildes = fd;
            my_aiocb.aio_buf = malloc(BUF_SIZE+1);
            my_aiocb.aio_nbytes = BUF_SIZE;
            my_aiocb.aio_offset = next_offset;
            /* Link the AIO request with a thread callback */
            my_aiocb.aio_sigevent.sigev_notify = SIGEV_THREAD;
            my_aiocb.aio_sigevent.notify_function = aio_completion_handler;
            my_aiocb.aio_sigevent.notify_attributes = NULL;
            my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb;
            ...
            ret = aio_read( &my_aiocb );
            }
            void aio_completion_handler( sigval_t sigval )
            {
            struct aiocb *req;
            req = (struct aiocb *)sigval.sival_ptr;
            /* Did the request complete? */
            if (aio_error( req ) == 0) {
            /* Request completed successfully, get the return status */
            ret = aio_return( req );
            }
            return;
            }
            

在清單 6 中，在創(chuàng)建自己的 aiocb 請求之后，我們使用 SIGEV_THREAD 請求了一個線程回調(diào)函數(shù)來作為通知方法。然后我們將指定特定的通知處理程序，并將要傳輸?shù)纳舷挛募虞d到處理程序中（在這種情況中，是個對 aiocb 請求自己的引用）。在這個處理程序中，我們簡單地引用到達的 sigval 指針并使用 AIO 函數(shù)來驗證請求已經(jīng)完成。

回頁首

對 AIO 進行系統(tǒng)優(yōu)化

proc 文件系統(tǒng)包含了兩個虛擬文件，它們可以用來對異步 I/O 的性能進行優(yōu)化：

• /proc/sys/fs/aio-nr 文件提供了系統(tǒng)范圍異步 I/O 請求現(xiàn)在的數(shù)目。
• /proc/sys/fs/aio-max-nr 文件是所允許的并發(fā)請求的最大個數(shù)。最大個數(shù)通常是 64KB，這對于大部分應(yīng)用程序來說都已經(jīng)足夠了。

回頁首

結(jié)束語

使用異步 I/O 可以幫助我們構(gòu)建 I/O 速度更快、效率更高的應(yīng)用程序。如果我們的應(yīng)用程序可以對處理和 I/O 操作重疊進行，那么 AIO 就可以幫助我們構(gòu)建可以更高效地使用可用 CPU 資源的應(yīng)用程序。盡管這種 I/O 模型與在大部分 Linux 應(yīng)用程序中使用的傳統(tǒng)阻塞模式都不同，但是異步通知模型在概念上來說卻非常簡單，可以簡化我們的設(shè)計。

bitsCN.nET*中國網(wǎng)管博客

bbs.bitsCN.com