文件系統(tǒng)

本文繼續(xù)來看 的文件系統(tǒng)部分， 將文件系統(tǒng)的設(shè)計分為 7 層： ，磁盤、緩存區(qū)、日志三個部分在前文已經(jīng)說了，本文接著講述 ，目錄，路徑三個層次。

這部分的理論知識可以參考文章：捋一捋文件系統(tǒng)。本文直接來看 xv6 的文件系統(tǒng)這部分是如何實現(xiàn)的。

文件系統(tǒng)布局

再來系統(tǒng)的看看 xv6 文件系統(tǒng)的布局圖：

這個圖與 文檔給出的布局圖有些不一樣，主要是日志區(qū)的位置變化了。 文檔給出的布局圖日志區(qū)位于文件系統(tǒng)的末尾，但是根據(jù)源碼來看日志區(qū)應(yīng)該是位于超級塊后面的。前文直接用的 文檔中的圖，應(yīng)該是有誤的，實在抱歉。我看了幾個版本的 源碼和文檔，源碼是日志區(qū)都是安排在超級塊后面，而文檔的布局圖描述的是將日志區(qū)放在末尾。不過這不是重點，不影響咱們理解，不管位于哪兒，在超級塊中做相應(yīng)修改就行。

引導(dǎo)塊、超級塊

第 0 塊是引導(dǎo)塊，里面存放的啟動程序也就是 ，詳見前文：實例講解多處理器下的計算機啟動

第 1 塊是超級塊，存有文件系統(tǒng)的元信息，相關(guān)結(jié)構(gòu)體定義如下：

structsuperblock{
uintsize;//Sizeoffilesystemimage(blocks)文件系統(tǒng)大小，也就是一共多少塊
uintnblocks;//Numberofdatablocks數(shù)據(jù)塊數(shù)量
uintninodes;//Numberofinodes.//i結(jié)點數(shù)量
uintnlog;//Numberoflogblocks//日志塊數(shù)量
uintlogstart;//Blocknumberoffirstlogblock//第一個日志塊塊號
uintinodestart;//Blocknumberoffirstinodeblock//第一個i結(jié)點所在塊號
uintbmapstart;//Blocknumberoffirstfreemapblock//第一個位圖塊塊號
};

可以看出超級塊實則就是文件系統(tǒng)布局的信息集合。在 中我們可以知道：

#defineNINODES200
#defineMAXOPBLOCKS10
#defineLOGSIZE(MAXOPBLOCKS*3)
#defineFSSIZE1000
#defineIPB(BSIZE/sizeof(structdinode))


intnbitmap=FSSIZE/(BSIZE*8)+1;
intninodeblocks=NINODES/IPB+1;
intnlog=LOGSIZE;

intnmeta=2+nlog+ninodeblocks+nbitmap;
intnblocks=FSSIZE-nmeta;

intlogstart=2;
intinodestart=2+nlog;
intbmapstart=2+nlog+ninodeblocks;

從上述代碼可以看出，文件系統(tǒng)的各個部分從哪開始，到哪結(jié)束都是可以明確計算出來的，所以其實不管將日志區(qū)安排在哪，我們都可以從超級塊中獲取相應(yīng)的位置大小信息。

數(shù)據(jù)區(qū)

緊接著超級塊的區(qū)域應(yīng)該是 ，但是 的內(nèi)容有些多有些復(fù)雜，我們放在后面講，先來看看數(shù)據(jù)區(qū)中數(shù)據(jù)塊的組織與管理。

數(shù)據(jù)塊的分配和釋放由位圖來管理，但位圖管理的區(qū)域不止數(shù)據(jù)區(qū)，而是整個文件系統(tǒng)。有關(guān)位圖的宏定義如下：

//Bitmapbitsperblock每個塊能有多少個bit
#defineBPB(BSIZE*8)
//Blockoffreemapcontainingbitforblockb塊b在哪個位圖塊上
#defineBBLOCK(b,sb)(b/BPB+sb.bmapstart)

分配回收

staticuintballoc(uintdev)
{
intb,bi,m;
structbuf*bp;

bp=0;
for(b=0;b//讀取位圖信息
for(bi=0;bi1<8);
if((bp->data[bi/8]&m)==0){//Isblockfree?如果該塊空閑
bp->data[bi/8]|=m;//Markblockinuse.標記該塊使用
log_write(bp);
brelse(bp);//釋放鎖
bzero(dev,b+bi);//將該塊置0
returnb+bi;//返回塊號
}
}
brelse(bp);//釋放鎖
}
panic("balloc:outofblocks");
}

staticvoidbfree(intdev,uintb)//釋放一個數(shù)據(jù)塊，相應(yīng)位圖清零
{
structbuf*bp;
intbi,m;

bp=bread(dev,BBLOCK(b,sb));
bi=b%BPB;
m=1<8);
if((bp->data[bi/8]&m)==0)
panic("freeingfreeblock");
bp->data[bi/8]&=~m;
log_write(bp);
brelse(bp);
}

位圖塊中每一位都代表著一塊，該位置 1 表示相應(yīng)的塊正在使用，該位置 0 表示相應(yīng)的塊空閑。分配數(shù)據(jù)塊就是在位圖中尋找空閑位，然后將其置 1 就代表分配出去了。

上述代碼涉及的都是比較簡單的位運算，有詳細的注釋，就不說明了，釋放一個數(shù)據(jù)塊的操作就是分配的逆操作，也不再贅述。

inode

磁盤上的 dinode

緊接著超級塊后面的區(qū)域是 區(qū)域， 定義的 共有 200 個，每個磁盤上的 定義如下：

structdinode{
shorttype;//Filetype
shortmajor;//Majordevicenumber(T_DEVonly)
shortminor;//Minordevicenumber(T_DEVonly)
shortnlink;//Numberoflinkstoinodeinfilesystem
uintsize;//Sizeoffile(bytes)
uintaddrs[NDIRECT+1];//Datablockaddresses
};
#defineNDIRECT12

表示該 指向的文件的類型，在 里面就只有三種類型，普通文件，目錄文件，設(shè)備文件

表示該文件的鏈接數(shù)，鏈接分為硬鏈接和軟連接，這里與鏈接數(shù)目直接相關(guān)的是硬鏈接，后面實現(xiàn)文件系統(tǒng)調(diào)用的時候我們會看到， 系統(tǒng)調(diào)用會創(chuàng)建一個新目錄項并且增加一個鏈接數(shù)。 系統(tǒng)調(diào)用將鏈接數(shù)減 1，如果該文件在內(nèi)存中的引用數(shù)和鏈接數(shù)都為 0 的話，則會刪除該文件。這部分咱們后面再慢慢聊，本文只捎帶提一下。

表示文件的大小，這里是以字節(jié)為單位。

在 里面使用 和 來區(qū)分設(shè)備，同一類設(shè)備有著相同的 ， 又表示該類設(shè)備中具體的某設(shè)備。后面我們會看到如果文件類型為設(shè)備，則讀寫的時候會根據(jù) 調(diào)用相應(yīng)設(shè)備的讀寫程序。

每個 有 11 個一級指針，一個間接指針，用來指向數(shù)據(jù)塊。這些都是可以改變的， 有個關(guān)于支持大文件的實現(xiàn)就是要增加一個間接索引來實現(xiàn)。

inode 緩存

磁盤上的 在內(nèi)存中也有相應(yīng)的緩存：

struct{
structspinlocklock;
structinodeinode[NINODE];
}icache;//磁盤上i結(jié)點在內(nèi)存中的緩存

內(nèi)存中的 定義如下：

structinode{
uintdev;//Devicenumber設(shè)備號
uintinum;//Inodenumberinode號
intref;//Referencecount引用數(shù)
structsleeplocklock;//protectseverythingbelowhere
intvalid;//inodehasbeenreadfromdisk?是否有效

shorttype;//copyofdiskinode
shortmajor;
shortminor;
shortnlink;
uintsize;
uintaddrs[NDIRECT+1];
};

內(nèi)存中的 比磁盤上的 多了幾個屬性，首先是設(shè)備號， 里面一切皆文件，設(shè)備也是文件，所以設(shè)備號來表示什么設(shè)備。但是 xv6 沒這么復(fù)雜，這里主要就是來區(qū)分磁盤的主盤和從盤。時為從盤， 時為主盤，這個值在讀寫磁盤的時候用到，用它來設(shè)置磁盤的 device 寄存器來指定主盤從盤。詳見：帶你了解磁盤驅(qū)動程序

表示引用數(shù)，這個要與 鏈接數(shù)作區(qū)別，目前可以暫且理解為 為磁盤上文件之間的關(guān)系，而 主要用于內(nèi)存中引用該文件的次數(shù)，比如 關(guān)閉文件使引用數(shù)減 1。這部分在文件系統(tǒng)調(diào)用的時候再作詳細講解。

表示是否有效，跟磁盤那里緩存塊中的數(shù)據(jù)是否有效一個意思，如果緩存中的數(shù)據(jù)是從磁盤中讀取過來的，則有效。通常無效是因為 剛分配，所以里面的數(shù)據(jù)無效。

整個 緩存區(qū)有一把自旋鎖，每個 緩存有把休眠鎖，為什么如此，道理還是同磁盤和緩存塊。首先它們都是公共資源，需要鎖來避免競爭條件。再者 的作用就是組織管理 ，像是一個分配器，訪問 的臨界區(qū)的時間是很短的，使用自旋鎖就行。而一個進程對某個 的使用時間可能很長，最好使用休眠鎖，其他進程也想要獲取該 的使用權(quán)時就休眠讓出 提高性能。

分配 inode

對于磁盤上的 ， 并沒有什么組織管理結(jié)構(gòu)，分配空閑 的方法就是簡單粗暴地從頭至尾循環(huán)查找空閑 。

structinode*
ialloc(uintdev,shorttype)
{
intinum;
structbuf*bp;
structdinode*dip;

for(inum=1;inum//讀取第inum個i結(jié)點所在的位置
dip=(structdinode*)bp->data+inum%IPB;//該i結(jié)點地址
if(dip->type==0){//afreeinode找到空閑i結(jié)點
memset(dip,0,sizeof(*dip));
dip->type=type;
log_write(bp);//markitallocatedonthedisk
brelse(bp);
returniget(dev,inum);//以內(nèi)存中的i結(jié)點形式返回
}
brelse(bp);
}
panic("ialloc:noinodes");
}

#defineIBLOCK(i,sb)((i)/IPB+sb.inodestart)
#defineIPB(BSIZE/sizeof(structdinode))

先來看看下面兩個宏定義， 表示一個塊中能有幾個 ， 表示第 個 在第幾塊。

分配數(shù)據(jù)塊的時候有位圖來組織管理，所以分配數(shù)據(jù)塊的時候就“從頭至尾”的查詢空閑位，而 沒有組織管理的機制，所以就直接從頭至尾的查詢 的使用情況。如果該 的 屬性為 0 表示該 空閑，可以分配，反之正是用當中不可分配。

分配了之后將該 初始化，將其數(shù)據(jù)全部置 0，然后賦其 屬性，表示該 指向一個 類型的文件。

分配了該 需要在磁盤上也將其標記為已分配，因為目前是在內(nèi)存中操作的，得同步到磁盤上去，所以直接調(diào)用 將該 所在的緩存塊同步到磁盤。當然并未真正地直接寫到磁盤了，只是在將該緩存數(shù)據(jù)標記為臟，關(guān)于日志，讀寫磁盤的操作本文不贅述了，可以參考前文：如何實現(xiàn)一個簡單的日志系統(tǒng)

回到分配 的函數(shù)上來，磁盤上的 已分配，得到了 號，但是文件系統(tǒng)實際工作的時候使用的是內(nèi)存中的 緩存，所以調(diào)用 來分配(獲取)一個內(nèi)存中的 來緩存 數(shù)據(jù)：

staticstructinode*iget(uintdev,uintinum)
{
structinode*ip,*empty;

acquire(&icache.lock);

//Istheinodealreadycached?如果該dinode在內(nèi)存中已緩存
empty=0;
for(ip=&icache.inode[0];ipif(ip->ref>0&&ip->dev==dev&&ip->inum==inum){//在緩存中找到該i結(jié)點
ip->ref++;//引用加1
release(&icache.lock);
returnip;
}
if(empty==0&&ip->ref==0)//Rememberemptyslot.記錄icache中空閑的inode
empty=ip;
}

//Recycleaninodecacheentry.
if(empty==0)
panic("iget:noinodes");
//該dinode在內(nèi)存中沒有緩存，分配一個空閑inodeempty
//根據(jù)參數(shù)，初始化該空閑inode，還沒讀入數(shù)據(jù)，valid設(shè)為0
ip=empty;
ip->dev=dev;
ip->inum=inum;
ip->ref=1;
ip->valid=0;
release(&icache.lock);

returnip;
}

如果磁盤上的 在 中已有緩存，那么直接將該 的引用數(shù)加 1，再返回該 就行。如果沒有緩存則分配一個空閑的 ，根據(jù)參數(shù)初始化 ，因為沒有實際讀入 的數(shù)據(jù)，所以 的 屬性置 0 表示無效。

使用修改 inode

使用 之前需要加鎖：

voidilock(structinode*ip)
{
structbuf*bp;
structdinode*dip;

if(ip==0||ip->ref1)//空指針引用小于1都是錯誤的
panic("ilock");

acquiresleep(&ip->lock);//上鎖

if(ip->valid==0){//有效位為0，從磁盤讀入數(shù)據(jù)
bp=bread(ip->dev,IBLOCK(ip->inum,sb));
dip=(structdinode*)bp->data+ip->inum%IPB;
ip->type=dip->type;
ip->major=dip->major;
ip->minor=dip->minor;
ip->nlink=dip->nlink;
ip->size=dip->size;
memmove(ip->addrs,dip->addrs,sizeof(ip->addrs));
brelse(bp);
ip->valid=1;
if(ip->type==0)
panic("ilock:notype");
}
}

分配 的時候并未從磁盤中 讀入數(shù)據(jù)，只是將 的 置 0 表示數(shù)據(jù)無效，正式讀入 數(shù)據(jù)在這加鎖的時候進行。

對緩存中 的修改需要同步到磁盤上的 ：

voidiupdate(structinode*ip)
{
structbuf*bp;
structdinode*dip;

bp=bread(ip->dev,IBLOCK(ip->inum,sb));//讀取磁盤上的i結(jié)點
dip=(structdinode*)bp->data+ip->inum%IPB;
dip->type=ip->type;//update
dip->major=ip->major;
dip->minor=ip->minor;
dip->nlink=ip->nlink;
dip->size=ip->size;
memmove(dip->addrs,ip->addrs,sizeof(ip->addrs));
log_write(bp);
brelse(bp);
}

用完 需要 “放下” 它：

voidiput(structinode*ip)
{
acquiresleep(&ip->lock);//取鎖
if(ip->valid&&ip->nlink==0){
//獲取該i結(jié)點的引用數(shù)
acquire(&icache.lock);
intr=ip->ref;
release(&icache.lock);

if(r==1){
//inodehasnolinksandnootherreferences:truncateandfree.
itrunc(ip);
ip->type=0;
iupdate(ip);
ip->valid=0;
}
}
releasesleep(&ip->lock);

acquire(&icache.lock);
ip->ref--;
release(&icache.lock);
}

該函數(shù)將 的引用數(shù)減 1，如果本身就是該 的最后一個引用，且鏈接數(shù)也為 0，那么調(diào)用 將該 指向的所有數(shù)據(jù)塊全部釋放，也就相當于刪除了 指向的文件。

表示該 已釋放，被回收到了 。將 信息更新到磁盤上的 之后將 置 0 表數(shù)據(jù)不再有效。

索引

的索引部分用來指向數(shù)據(jù)塊

staticuintbmap(structinode*ip,uintbn)//給i結(jié)點第bn個索引指向的地方分配塊
{
uintaddr,*a;
structbuf*bp;

//bn為直接索引
if(bn//如果第bn個索引指向的塊還未分配，則分配，否則返回塊號
if((addr=ip->addrs[bn])==0)
ip->addrs[bn]=addr=balloc(ip->dev);
returnaddr;
}

bn-=NDIRECT;//bn為間接索引

if(bn//Loadindirectblock,allocatingifnecessary.
if((addr=ip->addrs[NDIRECT])==0)//如果間接索引所在的塊還未分配，分配
ip->addrs[NDIRECT]=addr=balloc(ip->dev);
bp=bread(ip->dev,addr);//讀取一級索引塊
a=(uint*)bp->data;
if((addr=a[bn])==0){//如果該索引指向的塊還未分配，分配
a[bn]=addr=balloc(ip->dev);
log_write(bp);
}
brelse(bp);
returnaddr;//返回索引bn指向的塊的塊號
}

panic("bmap:outofrange");
}

返回索引 指向的數(shù)據(jù)塊塊號，如果該數(shù)據(jù)塊未分配，則分配之后再返回該塊塊號。

staticvoiditrunc(structinode*ip)
{
inti,j;
structbuf*bp;
uint*a;

for(i=0;i//釋放直接索引指向的數(shù)據(jù)塊
if(ip->addrs[i]){
bfree(ip->dev,ip->addrs[i]);
ip->addrs[i]=0;
}
}

if(ip->addrs[NDIRECT]){
bp=bread(ip->dev,ip->addrs[NDIRECT]);//讀取一級索引塊
a=(uint*)bp->data;
for(j=0;j//釋放一級索引指向的塊
if(a[j])
bfree(ip->dev,a[j]);
}
brelse(bp);
bfree(ip->dev,ip->addrs[NDIRECT]);//釋放一級索引塊
ip->addrs[NDIRECT]=0;
}

ip->size=0;
iupdate(ip);
}

，截斷 ，不知怎樣翻譯，但這個函數(shù)的實際工作就是將 所指向的數(shù)據(jù)塊全部釋放，也就相當于刪除文件了。具體的工作方式就是一個個的判斷索引是否有效，如果有效就調(diào)用 釋放，然后將該索引置為無效?；旧暇团c 做相反的工作。

讀寫數(shù)據(jù)

intreadi(structinode*ip,char*dst,uintoff,uintn)//從inode讀取數(shù)據(jù)
{
uinttot,m;
structbuf*bp;

if(ip->type==T_DEV){//如果該inode指向的是設(shè)備文件
if(ip->major0||ip->major>=NDEV||!devsw[ip->major].read)
return-1;
returndevsw[ip->major].read(ip,dst,n);//使用設(shè)備特有的讀取方式
}

if(off>ip->size||off+n//如果開始讀取的位置超過文件末尾，如果讀取的字節(jié)數(shù)是負數(shù)
return-1;
if(off+n>ip->size)//如果從偏移量開始的n字節(jié)超過文件末尾
n=ip->size-off;//則只能夠再讀取這么多字節(jié)

for(tot=0;tot//tol:目前總共已讀的字節(jié)數(shù)，n:需要讀取的字節(jié)數(shù),off:從這開始讀,dst:目的地
bp=bread(ip->dev,bmap(ip,off/BSIZE));//讀取off所在的數(shù)據(jù)塊到緩存塊
m=min(n-tot,BSIZE-off%BSIZE);//一次性最多讀取m字節(jié)
memmove(dst,bp->data+off%BSIZE,m);//賦值數(shù)據(jù)到dst
brelse(bp);//釋放緩存塊
}
returnn;
}

intwritei(structinode*ip,char*src,uintoff,uintn)
{
uinttot,m;
structbuf*bp;

if(ip->type==T_DEV){
if(ip->major0||ip->major>=NDEV||!devsw[ip->major].write)
return-1;
returndevsw[ip->major].write(ip,src,n);
}

if(off>ip->size||off+nreturn-1;
if(off+n>MAXFILE*BSIZE)
return-1;

for(tot=0;totdev,bmap(ip,off/BSIZE));
m=min(n-tot,BSIZE-off%BSIZE);
memmove(bp->data+off%BSIZE,src,m);
log_write(bp);
brelse(bp);
}

函數(shù)用來讀取數(shù)據(jù)，從 ip 指向的文件中，從 開始讀，讀取 字節(jié)到 中去。

如果 指向的文件類型是設(shè)備，那么讀取數(shù)據(jù)要使用專門的讀取方式，比如說控制臺有著自己專門的讀入數(shù)據(jù)方式，這些設(shè)備的讀取方法集合在 數(shù)組當中。關(guān)于這部分我們后面的文章再詳述，這里只說磁盤上的文件的讀寫。

緊接著判斷了一下參數(shù)的合理性，比如 不應(yīng)超過文件末尾，讀取的字節(jié)數(shù) 不應(yīng)該是負數(shù)，如果 超過了文件末尾，那么最多只能讀取 個字節(jié)數(shù)，要修改 的值。

文件數(shù)據(jù)可能有多塊， 表示 所在的塊數(shù)，這個塊數(shù)是相對于該文件開頭的塊號，調(diào)用 獲取 所在的絕對塊號。拿到 所在數(shù)據(jù)塊的絕對塊號之后調(diào)用 讀取該數(shù)據(jù)塊的數(shù)據(jù)到緩存塊 。

數(shù)據(jù)在內(nèi)存中已經(jīng)準備完畢，可以賦值移動數(shù)據(jù)了。但是每次讀取的數(shù)據(jù)有上限，不能超過 ，這是還需要讀取的字節(jié)數(shù)，不能超過 ，這是每次最多能夠讀取的字節(jié)數(shù)。不能超過這兩者，所以兩者之中取較小值。

，將數(shù)據(jù)源 中的數(shù)據(jù)寫 字節(jié)到 指向的文件中，從偏移量為 的地方開始寫。

基本上是與 相反的操作，只是最后需要更新 信息，因為像文件中寫數(shù)據(jù)，該文件會變大， 是文件的代表與文件一一對應(yīng)，需要更新 的 size 屬性，然后再調(diào)用 將 同步到磁盤上的 。

目錄

目錄也是文件，只是它的數(shù)據(jù)有些特殊，其數(shù)據(jù)是一個個目錄項，其主要屬性有文件名， 編號。

是一個文件的代言人，一個文件與一個 一一對應(yīng)，但是 的屬性里面并沒有文件名。文件名這個屬性在目錄項這指出，目錄項的主要作用就是將 和文件名聯(lián)系起來。

結(jié)構(gòu)定義

structdirent{//目錄項結(jié)構(gòu)
ushortinum;
charname[DIRSIZ];
};

#defineDIRSIZ14

中目錄項只由兩項組成，文件名和 編號。

查找目錄項

structinode*dirlookup(structinode*dp,char*name,uint*poff)
{
uintoff,inum;
structdirentde;

if(dp->type!=T_DIR)//如果該文件不是目錄文件
panic("dirlookupnotDIR");

for(off=0;offsize;off+=sizeof(de)){
if(readi(dp,(char*)&de,off,sizeof(de))!=sizeof(de))//讀取dp指向的目錄文件，每次讀一個目錄項
panic("dirlookupread");
if(de.inum==0)//如果是根目錄??????????????
continue;
if(namecmp(name,de.name)==0){//根據(jù)名字找文件
//entrymatchespathelement
if(poff)//記錄該目錄項在目錄中的偏移
*poff=off;
inum=de.inum;//name文件的inode編號
returniget(dp->dev,inum);//或取該inode
}
}

return0;
}

這個函數(shù)用來在 指向的目錄文件下尋找名為 的目錄項，將該目錄項的偏移量記錄在 中，最后返回名字為 的文件的 。

因此根據(jù)文件名查找文件的是指就是在目錄文件中查找目錄項的過程，具體的查找方式就是一個個的比對目錄項的名稱和要查找的文件名是否相同，如果相同，則找到，反之說明該目錄下并沒有要查找的文件。

添加目錄項

intdirlink(structinode*dp,char*name,uintinum)
{
intoff;
structdirentde;
structinode*ip;

//Checkthatnameisnotpresent.
if((ip=dirlookup(dp,name,0))!=0){
iput(ip);//dirlookup調(diào)用iget使引用數(shù)加1，所以調(diào)用iput使引用數(shù)減1
return-1;//name目錄項已存在，返回-1
}

//Lookforanemptydirent.
for(off=0;offsize;off+=sizeof(de)){
if(readi(dp,(char*)&de,off,sizeof(de))!=sizeof(de))
panic("dirlinkread");
if(de.inum==0)//找到一個空閑目錄項
break;
}

strncpy(de.name,name,DIRSIZ);//設(shè)置目錄項的文件名字
de.inum=inum;//設(shè)置目錄項的i結(jié)點編號
if(writei(dp,(char*)&de,off,sizeof(de))!=sizeof(de))//將該目錄項寫進dp指向的目錄文件中
panic("dirlink");

return0;
}

此函數(shù)用來在 指向的目錄文件中添加一個目錄項，通常是創(chuàng)建了一個新文件，需要在該目錄下添加這個新文件的信息。

首先查找該目錄項是否存在，如果不存在則找一個空閑目錄項位置，將新文件的 和文件名寫進去。

路徑

路徑，何為路徑，比如常見的 ，仔細觀察，會發(fā)現(xiàn)，路徑實則是一個個文件名組成的，這個文件可能是目錄文件，也可能是普通文件。一般最后一項是普通文件名，中間的都是目錄文件名。

另外像 這種路徑以 '/' 開頭表示絕對路徑， 這種不以 '/' 開頭的表示相對路徑。這兩種路徑大家應(yīng)該都很熟悉了，不再多做解釋，或者可以參考文章捋一捋文件系統(tǒng)，其中詳細的捋了捋文件系統(tǒng)的理論知識。

不論哪一種路徑表示，都需要一個路徑解析函數(shù)，將其中一個個文件名給提取出來：

staticchar*skipelem(char*path,char*name)
{
char*s;
intlen;

while(*path=='/')//跳過'/'
path++;
if(*path==0)//路徑空
return0;
s=path;
while(*path!='/'&&*path!=0)//path繼續(xù)向后移，剝出最前面的目錄名
path++;
len=path-s;//記錄該目錄名的長度
if(len>=DIRSIZ)
memmove(name,s,DIRSIZ);//將該目錄名復(fù)制給name
else{
memmove(name,s,len);
name[len]=0;
}
while(*path=='/')//繼續(xù)跳過'/'
path++;
returnpath;//返回剩下的路徑
}

調(diào)用一次解析一個頭部的文件名放在 中，返回剩下的路徑。

用源碼注釋中的例子來說明：

skipelem("a/bb/c",name)="bb/c",settingname="a"
skipelem("http:///a//bb",name)="bb",settingname="a"
skipelem("a",name)="",settingname="a"
skipelem("",name)=skipelem("http:////",name)=0

staticstructinode*
namex(char*path,intnameiparent,char*name)
{
structinode*ip,*next;

if(*path=='/')//絕對路徑
ip=iget(ROOTDEV,ROOTINO);//讀取根目錄
else//相對路徑
ip=idup(myproc()->cwd);//讀取當前工作目錄

while((path=skipelem(path,name))!=0){
ilock(ip);
if(ip->type!=T_DIR){
iunlockput(ip);
return0;
}
if(nameiparent&&*path==''){//如果是要返回父結(jié)點，并且剩下的路徑已經(jīng)為空，則當前結(jié)點就是i結(jié)點直接返回
//Stoponelevelearly.
iunlock(ip);
returnip;
}
if((next=dirlookup(ip,name,0))==0){//查詢下一個目錄
iunlockput(ip);
return0;
}
iunlockput(ip);
ip=next;//當前目錄指向下一個，然后while循環(huán)，直到解析到最后
}
if(nameiparent){
iput(ip);
return0;
}
returnip;
}

這個函數(shù)根據(jù)路徑返回 ，比如說路徑 ，如果 有效，則返回文件 的 ，如果 無效，則返回文件 的 。

這個函數(shù)主要是對路徑解析函數(shù) 和查找目錄項函數(shù) 函數(shù)的運用，根據(jù)路徑查找文件的步驟大致如下：

• 獲取當前目錄的
• 根據(jù) 獲取目錄文件
• 在該目錄文件下根據(jù)文件名查找文件/目錄
• 循環(huán)上述過程直到文件被找到

函數(shù)就是上述過程的實現(xiàn)，至于這個函數(shù)的具體怎么實現(xiàn)的，就不詳細說明了，可以自己舉個例子根據(jù)代碼模擬一下過程就明白了。在模擬的過程中主要注意幾個條件判斷：

• (path = skipelem(path, name)) != 0，當 為空字符串的才返回 0，也就是說 skipelem("", name) = 0。path 指向一個空字符串，并不是說 path 本身為空
• if(nameiparent && *path == '')， 為空字符串的時候也就是 "" 的時候 *path = ''。

另外如果是相對路徑的話，當前目錄需要從進程 中的 屬性中獲取，相關(guān)內(nèi)容后面進程再詳述。

本文主要介紹了 文件系統(tǒng) ，目錄，路徑三個層次的設(shè)計與實現(xiàn)，應(yīng)該對這三個概念會有個更深刻的認識。 是文件的代表，與文件一一對應(yīng)，目錄也是文件，只是其數(shù)據(jù)是其他文件的信息，也就是一個個目錄項。目錄項是其他文件的文件名和相應(yīng)的 編號組合而成。而路徑呢？就是一個個文件名組合在一起的字符串?？梢允褂寐窂浇馕龊瘮?shù)將一個個文件名解析出來，然后根據(jù)一層層目錄中的目錄項從上至下地查找文件。

好啦本文就到這里了，有什么錯誤還請批評指針，也歡迎大家來同我討論交流一起學(xué)習進步。