环境：Linux 0.11 / Linux 3.4.2
参考书籍：Linux内核完全剖析基于0.11内核-赵炯
一、Linux中使用文件系统的部分
1.1关于Linux中高速缓冲区的管理程序
1.2文件系统的底层通用函数(对于硬盘的读写，分配释放等，对于目录节点inode的管理，以及内存和磁盘的映射
1.3文件数据进行读写的操作模块(vfs:虚拟文件系统 硬件驱动和文件系统的关系)
1.4文件系统与其他程序接口的实现(fopen fclose等等)
二、文件系统的基本概念
对于一个硬盘设备，通常都会划分出几个盘片，每个盘片存放着一个不同的文件系统。比如下图将一个硬盘分成了4个分区，包含了4个不同的文件系统。其中主引导扇区中存放着磁盘引导程序和分区表信息（指明硬盘上的每个分区的类型）。
对于Linux0.11内核采用的文件系统是MINIX文件系统，它的分布如下图哦所示：
① 引导块：用来引导设备的，通常在上电时由BIOS自动读入运行的数据。对于非引导设备的盘引导块内容为空。
② 超级快：相当于文件系统的描述符，定义如下：
struct super_block {
unsigned short s_ninodes;
unsigned short s_nzones;
unsigned short s_imap_blocks;
unsigned short s_zmap_blocks;
unsigned short s_firstdatazone;
unsigned short s_log_zone_size;
unsigned long s_max_size;
unsigned short s_magic;
/* These are only in memory */
struct buffer_head * s_imap[8];
struct buffer_head * s_zmap[8];
unsigned short s_dev;
struct m_inode * s_isup;
struct m_inode * s_imount;
unsigned long s_time;
struct task_struct * s_wait;
unsigned char s_lock;
unsigned char s_rd_only;
unsigned char s_dirt;
};
s_ninode表示当前块设备的inode节点数。每个inode代表一个文件。
s_nzones表示当前块设备上以逻辑块为大小 （1KB）的逻辑块数。
s_imap_blocks与s_zmap_blocks分别表示当前块设备的inode节点位图和逻辑块位图所占用的逻辑块数。
逻辑块位图用于描述当前设备每个磁盘块的使用情况。如果为0，表示对应的磁盘块是空闲的，可以分配使用。当一个磁盘块被分配占用后，对应的逻辑块位图的比特位被置1
根据超级块数据结构中定义，s_zmap是一个数组，它占用了8块磁盘块大小，每个块大小 是1024字节，因此总共可以管理8192*8个比特位，每个比特位分别对应一个数据磁盘块，总计这8个磁盘块大小可以管理655356数据磁盘块。
inode节点位图是用来标记iNode节点的使用情况。与逻辑块位图 类似，当创建一个文件时候，我们分配一个iNode数据结构，并且些iNode实例对应的inode位图数组对应的位需要被置1。
s_firstdatazones表示当前块设备上数据区开始位置占用的第一个逻辑块的块号。
s_max_size表示当前块设备上，以字节为单位的最大文件 的长度。
s_magic表示文件系统的魔数，标示了文件系统的类型。④ i节点位图：类似逻辑块位图。
③ 逻辑块位图：每一位对应于逻辑块的使用情况，如果对应逻辑块使用了，则逻辑块位图的位置1.
⑤ i节点：是目录与磁盘的桥接， 文件的属性描述。
⑥ 逻辑块：用来存储数据的逻辑单元。
对于i节点定义在文件/include/linux/fs.h中，如下所示：
struct m_inode {
unsigned short i_mode; //文件的类型和属性
unsigned short i_uid; //宿主用户id
unsigned long i_size; //文件的大小
unsigned long i_mtime; //文件的修改时间
unsigned char i_gid; //用户组id
unsigned char i_nlinks; //硬链接数
unsigned short i_zone[9]; //表示文件和磁盘的映射关系
//i_zone[6]如果你的文件大小只只用了7个逻辑块大小以内,那么这个数组每一个单源存储了一个逻辑块号
//i_zone[7]一次间接块号，如果占用的逻辑块大小大于7，小于512+7则占用一次逻辑块号
//i_zone[8]二次间接块号, 如果占用的逻辑块大小大于512 + 7，小于512 * 512 + 7则启动二次逻辑块号
/* these are in memory also */
struct task_struct * i_wait;
unsigned long i_atime;
unsigned long i_ctime;
unsigned short i_dev;
unsigned short i_num;
unsigned short i_count;
unsigned char i_lock;
unsigned char i_dirt;
unsigned char i_pipe;
unsigned char i_mount;
unsigned char i_seek;
unsigned char i_update;
};i_mode是一个us类型的变量，用来保存文件的类型和属性，具体定义如下所示：
1、高速缓冲区(buffer.c)
高速缓冲区是文件系统访问块设备数据的桥梁也是必经之道。如果内核对块设备进行数据读写，每次读写的I/O操作的时间与cpu自身的处理速度相比是非常慢的。因此内核会在内存中开辟一块高速缓冲区，并将其分成一个个与磁盘数据块大小相同的缓冲块进行管理。
在高速缓冲区中会存放着最近使用过的块设备中的数据块。当内核需要读取块设备上的数据块的时候，会先在高速缓冲区进行查找，如果相应数据已经在缓冲中，就无需从块设备上读。如果数据不在缓冲区中，就会发出读块设备的命令，将数据读到高速缓冲区中。当需要把数据写到块设备中时，内核会在高速缓冲区中申请一块空闲缓冲块临时存放这些数据，当执行设备数据同步命令的时候，才会真正的写入到块设备之中。
高速缓冲区的结构如下图所示：
对于linux 0.11内核，每个缓冲块的大小都是1024字节，与磁盘上的逻辑块大小相同。缓冲头结构的定义在文件/include/linux/fs.h中
struct buffer_head {
char * b_data; //指向缓冲块的指针
unsigned long b_blocknr; //块号
unsigned short b_dev; //数据源的设备号(0==free)
unsigned char b_uptodate; //表示数据是否被更新
unsigned char b_dirt; //0-未修改，1-已修改
unsigned char b_count; //使用该数据块的用户数
unsigned char b_lock; //缓冲区是否被锁定
struct task_struct * b_wait; //如果缓冲区被锁定，有新的进程想访问该数据块就会加入此链表
struct buffer_head * b_prev; //hash队列前一块
struct buffer_head * b_next; //hash队列后一块
struct buffer_head * b_prev_free; //空闲表上前一块
struct buffer_head * b_next_free; //空闲表上后一块
};缓冲区的维护依靠的是一个hash列表和一个free_list空闲列表。在buffer.c程序中定义了一个有307个buffer_head指针的hash数组。hash数组的hash函数是由（设备号^逻辑块号）% 307得到。
在buffer_head中定义的b_prev和b_next指针就是用于散列在同一个hash表项时用于双向链接的。而b_prev_free和b_next_free指针就是用于维护一个所有缓冲块的双向链表。
某一时刻的hash表和free_list状态如下图所示：
内核程序在使用高速缓冲区的缓冲块时，需要指定设备号(dev)和访问设备数据的逻辑块号(block)，然后调用函数bread()、bread_page()和breada()操作，这三个函数的本质都是调用缓冲区搜索函数getblk()来搜索缓冲块中最为空闲的缓冲块。
getblk()函数代码如下：
//用来判断缓冲区的修改和锁定标志
#define BADNESS(bh) (((bh)->b_dirt<<1)+(bh)->b_lock)
//传入参数dev和block
struct buffer_head * getblk(int dev,int block)
{
struct buffer_head * tmp, * bh;
repeat:
if (bh = get_hash_table(dev,block)) //搜索哈希表，如果对应缓冲块已经存在在哈希表中，直接返回该指针。
return bh;
//tmp指向空闲队列
tmp = free_list;
do {
//如果缓冲区的b_count不等于0表示在使用，直接跳过
//即使一个缓冲区的b_count=0也不一定是未使用过。
//比如一个进程执行breada()函数读取几个块，在执行完ll_rw_block()命令后就会释放b_count，但此时读取的操作还在进行，因此b_count=0,b_lock=1.
if (tmp->b_count)
continue;
//找到一个BADNESS值最小的缓冲区
if (!bh || BADNESS(tmp)<BADNESS(bh)) {
bh = tmp;
if (!BADNESS(tmp))
break;
}
/* and repeat until we find something good */
} while ((tmp = tmp->b_next_free) != free_list);
//如果所有的缓冲区都被使用，则进入睡眠状态等待唤醒。
if (!bh) {
sleep_on(&buffer_wait);
goto repeat;
}
//此时已经找到了一个BADNESS最小的缓冲块，等待该缓冲区解锁
wait_on_buffer(bh);
//解锁完后如果由被占用则重复
if (bh->b_count)
goto repeat;
//如果缓冲区已经被修改，先进行数据同步。
while (bh->b_dirt) {
sync_dev(bh->b_dev);
wait_on_buffer(bh);
if (bh->b_count)
goto repeat;
}
/* NOTE!! While we slept waiting for this block, somebody else might */
/* already have added "this" block to the cache. check it */
//在本进程睡眠的过程中，其他进程有可能吧该数据块加入到哈希表中，因此需要先寻找判断。
if (find_buffer(dev,block))
goto repeat;
/* OK, FINALLY we know that this buffer is the only one of it's kind, */
/* and that it's unused (b_count=0), unlocked (b_lock=0), and clean */
//最后得到的缓冲块b_count=0,b_dirt=0,b_uptodate=0,
//因此需要占用该缓冲块
bh->b_count=1;
bh->b_dirt=0;
bh->b_uptodate=0;
//从哈希列表和空闲队列移除，指定新的设备号和块号，再插入
remove_from_queues(bh);
bh->b_dev=dev;
bh->b_blocknr=block;
insert_into_queues(bh);
return bh;
}2、文件系统底层操作函数(super.c,bitmap.c,truncate.c,inode.c和namei.c)
bitmap.c
free_block(int dev, int block)
释放设备dev上数据区的逻辑块block，复位逻辑块block对应的逻辑块位图比特位
new_block(int dev)
向设备申请一个逻辑块，该函数会在获取该其超级块，并在超级块中的逻辑位图寻找第一个值为0的bit,然后在对应逻辑块位图置位该bit。为该逻辑块取得在高速缓冲区取得一个对应缓冲块，并更新标志，最后返回逻辑块号。
free_inode(struct m_inode* inode)
释放指定inode节点
new_inode(int dev)
为指定设备创建一个Inode节点
truncate.c
truncate(struct m_inode* inode)
将节点对应的文件长度截为0，主要调用free_ind和free_dind释放一次和二次间接块。
inode.c
wait_on_inode(struct m_inode * inode)
等待一个inode节点空闲
lock_inode(struct m_inode * inode)
锁定一个inode节点
unlock_inode(struct m_inode * inode)
解锁一个inode节点，并唤醒等待队列
invalidate_inodes(int dev)
扫描inode表数组，如果是指定设备使用的i节点就释放
sync_inodes(void)
把i节点表上的所有节点写入到高速缓冲区等待同步
bmap
文件数据块映射到盘块的处理操作，该函数把指定的文件数据块block对应到设备上逻辑块上，并返回逻辑块号。如果创建标志 置位，则在设备上对应逻辑块不存在时就申请新磁盘块，返回文件数据块block对应在设备上的逻辑块号（盘块号）。
iput、iget
iput 释放一个inode节点。
主要是对i_count引用次数进行操作，把i节点引用数值减1并且若是管道i节点，则唤醒等待进程若是块设备文件i节点则刷新设备若i节点的链接计数为0，则释放该i节点占用的所有磁盘逻辑块，并释放该节点
iget 获得一个inode节点。
从设备上读取指定节点号的i节点到内存i节点表中，并返回该i节点指针首先在位于高速缓冲区的i节点表中寻找，若找到指定节点号的i节点则再经过一些判断处理后返回i节点指针否则通过设备号和指定i节点号，从设备中读取的i节点信息，放入在i节点表中申请的空闲节点中，并返回该i节点指针
read_inode write_inode
找到指定的设备，通过设备号找到他的超级块，超级块计算要读写的块号，调用bread将其读写入高速缓冲区中，读的话将高速缓冲区的b_data读到内存，释放高速缓冲区。写的话将数据写到高速缓冲区的b_data并设置dirt置位，等待系统sys_sync进行写盘，释放高速缓冲区。
super.c
此文件中主要存放这对文件系统超级块的管理函数。
get_super()函数在指定了设备号的情况下，返回对应的超级块的指针
put_super()函数用于释放超级块，在调用函数umount()函数的会调用此函数
read_super()函数用于把指定设备的文件系统超级块读入缓冲区，并登记到超级块数组，最后返回该超级块的指针
sys_umount()系统调用用于卸载一个设备文件名的文件系统
sys_mount()用于往一个目录上挂载一个文件系统
mount_root()用于挂载根文件系统
namei.c
实现了根据目录名或文件名寻找对应i节点的函数namei()，以及关于目录的建立和删除、目录项的建立和删除等操作和系统调用
3、文件数据进行读写的操作模块
本部分是文件系统的第三个部分，主要包含对块设备，字符设备，管道文件，普通文件的读写函数（用作给系统调用提供读写接口）以及系统调用sys_read()和sys_write()。关系如下图所示：
block_dev.c
block_write(int dev, long *pos, char *buf, int count)
int block_write(int dev, long * pos, char * buf, int count)
{
int block = *pos >> BLOCK_SIZE_BITS;
int offset = *pos & (BLOCK_SIZE-1);
int chars;
int written = 0;
struct buffer_head * bh;
register char * p;
while (count>0) {
chars = BLOCK_SIZE - offset;
if (chars > count)
chars=count;
if (chars == BLOCK_SIZE)
bh = getblk(dev,block);
else
bh = breada(dev,block,block+1,block+2,-1);
block++;
if (!bh)
return written?written:-EIO;
p = offset + bh->b_data;
offset = 0;
*pos += chars;
written += chars;
count -= chars;
while (chars-->0)
*(p++) = get_fs_byte(buf++);
bh->b_dirt = 1;
brelse(bh);
}
return written;
}数据块写函数，向指定设备dev的偏移量pos处，从buf缓冲区开始写入count字节的数据。返回成功写入的字节数。
写数据流程：
① 根据偏移量pos会计算出开始写的盘号block，和在第一个数据块中的偏移量offset。
② 针对要写入的字节数count开始循环进行写操作。
2.1首先计算当前数据块剩余可写入数据的大小chars。如果剩余大小chars大于需要写入的数据count，则chars = count。
2.2 如果剩余可写入数据大小为一块数据的内容，则直接申请1块高速缓冲块。
2.3 否则就需要读入将被写入的数据的数据块，并预读取下两块数据，然后将块号递增1，为循环写入做准备。
block_read(int dev, unsigned long *pos, char *buf, int count)
数据块读函数，从指定设备dev的pos处读取数据，和write函数流程类似。
file_dev.c
提供普通文件的读写函数，供系统调用read()和write()使用
file_read(struct m_inode * inode, struct file * filp, char * buf, int count)
int file_read(struct m_inode * inode, struct file * filp, char * buf, int count)
{
int left,chars,nr;
struct buffer_head * bh;
if ((left=count)<=0)
return 0;
while (left) {
if (nr = bmap(inode,(filp->f_pos)/BLOCK_SIZE)) {
if (!(bh=bread(inode->i_dev,nr)))
break;
} else
bh = NULL;
nr = filp->f_pos % BLOCK_SIZE;
chars = MIN( BLOCK_SIZE-nr , left );
filp->f_pos += chars;
left -= chars;
if (bh) {
char * p = nr + bh->b_data;
while (chars-->0)
put_fs_byte(*(p++),buf++);
brelse(bh);
} else {
while (chars-->0)
put_fs_byte(0,buf++);
}
}
inode->i_atime = CURRENT_TIME;
return (count-left)?(count-left):-ERROR;
}file文件读数据流程：
① 若要读取的字节数count <= 0直接返回，否则用left保存要读取的字节数开始循环读取。
② 利用bmap()函数获取该文件的读写指针所在位置的逻辑块号nr，若nr!=0则读取该逻辑块，若nr=0表示数据块不存在，缓冲块bh指向空。
③ 计算读写指针在该逻辑块中的偏移量nr，将该数据块剩余的数据BLOCK_SIZE-nr和剩余需要读取字节数left进行比较，如果BLOCK_SIZE-nr > left表示该快是最后一个数据块，反之还需要读取下一个数据块，调整文件指针后移。
file_write(struct m_inode * inode, struct file * filp, char * buf, int count)
和读函数类似
pipe.c
管道文件是多进程通信进行数据交互的一种基本方式，在本文件中提供了read_pipe()，write_pipe()同时实现了系统调用sys_pipe()。
在创建管道的时候，程序会专门申请一个管道i节点，并为管道分配一页缓冲区（4kb），i节点的i_size字段保存着管道缓冲区地址,管道数据头指针存放在i_zone[0]字段中，管道数据尾指针存放在i_zone[1]指针中，如下图所示：
char_dev.c
该文件包含字符设备的访问函数。主要包含rw_ttyx()串口中端设备读写函数，rw_tty()控制台终端读写函数，rw_memory()内存设备读写函数。以及rw_char()字符设备读写接口函数。