文件系统对页高速缓存的操作

1.具体文件系统

conststructfile_operationsext2_file_operations={

.llseek=generic_file_llseek,

.read=do_sync_read,

.write=do_sync_write,

.aio_read=generic_file_aio_read,

.aio_write=generic_file_aio_write,

.unlocked_ioctl=ext2_ioctl,

#ifdefCONFIG_COMPAT

.compat_ioctl=ext2_compat_ioctl,

#endif

.mmap=generic_file_mmap,

.open=generic_file_open,

.release=ext2_release_file,

.fsync=simple_fsync,

.splice_read=generic_file_splice_read,

.splice_write=generic_file_splice_write,

};

1.1.可以看到ext2的read其实际上执行的是do_sync_read()函数。

ssize_tdo_sync_read(structfile*filp,char__user*buf,size_tlen,loff_t*ppos)

{

structioveciov={.iov_base=buf,.iov_len=len};

structkiocbkiocb;

ssize_tret;

init_sync_kiocb(&kiocb,filp);

kiocb.ki_pos=*ppos;

kiocb.ki_left=len;

for(;;){

ret=filp->f_op->aio_read(&kiocb,&iov,1,kiocb.ki_pos);//读操作开始

if(ret!=-EIOCBRETRY)

break;

wait_on_retry_sync_kiocb(&kiocb);

}

if(-EIOCBQUEUED==ret)

ret=wait_on_sync_kiocb(&kiocb);

*ppos=kiocb.ki_pos;

returnret;

1.2.generic_file_aio_read函数

if(filp->f_flags&O_DIRECT){

loff_tsize;

structaddress_space*mapping;

structinode*inode;

mapping=filp->f_mapping;

inode=mapping->host;

if(!count)

gotoout;/*skipatime*/

size=i_size_read(inode);

if(pos<size){

retval=filemap_write_and_wait_range(mapping,pos,

pos+iov_length(iov,nr_segs)-1);

if(!retval){

retval=mapping->a_ops->direct_IO(READ,iocb,

iov,pos,nr_segs);

}

if(retval>0)

*ppos=pos+retval;

if(retval){

file_accessed(filp);

gotoout;

}

}

for(seg=0;seg<nr_segs;seg++){

read_descriptor_tdesc;

//将iovec结构转换成read_descriptor_t的结构

desc.written=0;

desc.arg.buf=iov[seg].iov_base;

desc.count=iov[seg].iov_len;

if(desc.count==0)

continue;

desc.error=0;

do_generic_file_read(filp,ppos,&desc,file_read_actor);

retval+=desc.written;

if(desc.error){

retval=retval?:desc.error;

break;

}

if(desc.count>0)

break;

}

out:

returnretval;

typedefstruct{

size_twritten;//存放不断变换着的已传送的字节数

size_tcount;//存放不断变化着的未传送的字节数

union{

char__user*buf;//缓冲区的当前位置

void*data;

}arg;

interror;//读操作期间遇到的任何的错误码

}read_descriptor_t;

2.追踪页缓存

2.1.do_generic_file_read函数

staticvoiddo_generic_file_read(structfile*filp,loff_t*ppos,

read_descriptor_t*desc,read_actor_tactor)

{

structaddress_space*mapping=filp->f_mapping;//获取页高速缓存

structinode*inode=mapping->host;//获取inode

structfile_ra_state*ra=&filp->f_ra;

pgoff_tindex;

pgoff_tlast_index;

pgoff_tprev_index;

unsignedlongoffset;/*offsetintopagecachepage*/

unsignedintprev_offset;

interror

.............................

.............................

index=*ppos>>PAGE_CACHE_SHIFT;//确定本次读取的是文件中的第几个页

prev_index=ra->prev_pos>>PAGE_CACHE_SHIFT;//上次读取的是第几个页，即原来预读保存了上次的位置

prev_offset=ra->prev_pos&(PAGE_CACHE_SIZE-1);

last_index=(*ppos+desc->count+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;//下次读操作完成后的位置

offset=*ppos&~PAGE_CACHE_MASK;//请求的第一个字节在页内的偏移量

for(;;){

structpage*page;

pgoff_tend_index;

loff_tisize;

unsignedlongnr,ret;

cond_resched();

find_page:

page=find_get_page(mapping,index);

if(!page){

page_cache_sync_readahead(mapping,

ra,filp,

index,last_index-index);

page=find_get_page(mapping,index);

if(unlikely(page==NULL))

gotono_cached_page;

}

if(PageReadahead(page)){

page_cache_async_readahead(mapping,

ra,filp,page,

index,last_index-index);

}

if(!PageUptodate(page)){

if(inode->i_blkbits==PAGE_CACHE_SHIFT||

!mapping->a_ops->is_partially_uptodate)

gotopage_not_up_to_date;

if(!trylock_page(page))

gotopage_not_up_to_date;

if(!mapping->a_ops->is_partially_uptodate(page,

desc,offset))

gotopage_not_up_to_date_locked;

unlock_page(page);

}

page_ok://表示页已经在页高速缓存中了

isize=i_size_read(inode);//对应的文件的大小

end_index=(isize-1)>>PAGE_CACHE_SHIFT;//最后的页缓存序号

if(unlikely(!isize||index>end_index)){

page_cache_release(page);

gotoout;

}

/*nristhemaximumnumberofbytestocopyfromthispage*/

nr=PAGE_CACHE_SIZE;

if(index==end_index){

nr=((isize-1)&~PAGE_CACHE_MASK)+1;

if(nr<=offset){

page_cache_release(page);

gotoout;

}

}

nr=nr-offset;

.............

//对index和offset进行处理，目的是选择下一个要获取的页。

ret=actor(desc,page,offset,nr);

offset+=ret;

index+=offset>>PAGE_CACHE_SHIFT;

offset&=~PAGE_CACHE_MASK;

prev_offset=offset;

page_cache_release(page);//释放这个页，数据已经从内核态拷贝到了用户空间，

if(ret==nr&&desc->count)//nr表示需要拷贝的字节数，如果没有拷贝完成，continue

continue;

gotoout;

page_not_up_to_date_locked:

/*Diditgettruncatedbeforewegotthelock?*/

//有可能在锁页面的时候`有其它的进程将页面移除了页缓存区

//在这种情况下：将page解锁`并减少它的使用计数，重新循环```

//重新进入循环后，在页缓存区找不到对应的page.就会重新分配一个新的page

if(!page->mapping){

unlock_page(page);

page_cache_release(page);

continue;

}

/*Didsomebodyelsefillitalready?*/

//在加锁的时候，有其它的进程完成了从文件系统到具体页面的映射?

//在这种情况下，返回到page_ok.直接将页面上的内容copy到用户空间即可

if(PageUptodate(page)){

unlock_page(page);

gotopage_ok;

}

readpage:

/*Starttheactualread.Thereadwillunlockthepage.*/

error=mapping->a_ops->readpage(filp,page);//调用具体的readpage函数，在后面会分析。

if(unlikely(error)){//如果发生了AOP_TRUNCATED_PAGE错误，则回到find_page重新进行获取

if(error==AOP_TRUNCATED_PAGE){

page_cache_release(page);

gotofind_page;

}

gotoreadpage_error;

}

//如果PG_uptodata标志仍然末设置.就一直等待，一直到page不处于锁定状态

//在将文件系统的内容读入page之前，page一直是处理Lock状态的。一直到

//读取完成后，才会将页面解锁

if(!PageUptodate(page)){

error=lock_page_killable(page);

if(unlikely(error))

gotoreadpage_error;

if(!PageUptodate(page)){

if(page->mapping==NULL){

/*

*invalidate_inode_pagesgotit

*/

unlock_page(page);

page_cache_release(page);

gotofind_page;

}

unlock_page(page);

shrink_readahead_size_eio(filp,ra);

error=-EIO;

gotoreadpage_error;

}

unlock_page(page);

}

gotopage_ok;//读取成功

no_cached_page:

/*

*Ok,itwasn'tcached,soweneedtocreateanew

*page..

*/

//新分匹一个页面

page=page_cache_alloc_cold(mapping);

if(!page){

desc->error=-ENOMEM;

gotoout;

}

//将分得的页加到页缓存区和LRU

error=add_to_page_cache_lru(page,mapping,

index,GFP_KERNEL);

//向缓存中添加页时，如果因为页已经存在而产生错误，就跳转到find_Page处再试一次

if(error){

page_cache_release(page);

if(error==-EEXIST)

gotofind_page;

desc->error=error;//如果不是已经存在的错误，而是其他的错误，则记录该错误，并跳出for循环

gotoout;

}

gotoreadpage;//当成功的分配页，并将页加入页缓存和LRU后，就让指针page指向新页，并挑战到readpage,开始读取。

}

out:

ra->prev_pos=prev_index;

ra->prev_pos<<=PAGE_CACHE_SHIFT;

ra->prev_pos|=prev_offset;

*ppos=((loff_t)index<<PAGE_CACHE_SHIFT)+offset;//计算实际的偏移量

file_accessed(filp);//更新文件的最后一次访问时间。

}

3.readpage()函数

conststructaddress_space_operationsext2_aops={

.readpage=ext2_readpage,

.readpages=ext2_readpages,

.writepage=ext2_writepage,

.sync_page=block_sync_page,

.write_begin=ext2_write_begin,

.write_end=generic_write_end,

.bmap=ext2_bmap,

.direct_IO=ext2_direct_IO,

.writepages=ext2_writepages,

.migratepage=buffer_migrate_page,

.is_partially_uptodate=block_is_partially_uptodate,

.error_remove_page=generic_error_remove_page,

};

staticintext2_readpage(structfile*file,structpage*page)

{

returnmpage_readpage(page,ext2_get_block);

}

structbio{

sector_tbi_sector;//该bio结构所要传输的第一个（512字节）扇区：磁盘的位置

structbio*bi_next;//请求链表

structblock_device*bi_bdev;//相关的块设备

unsignedlongbi_flags//状态和命令标志

unsignedlongbi_rw;//读写

unsignedshortbi_vcnt;//bio_vesc偏移的个数

unsignedshortbi_idx;//bi_io_vec的当前索引

unsignedshortbi_phys_segments;//结合后的片段数目

unsignedshortbi_hw_segments;//重映射后的片段数目

unsignedintbi_size;//I/O计数

unsignedintbi_hw_front_size;//第一个可合并的段大小;

unsignedintbi_hw_back_size;//最后一个可合并的段大小

unsignedintbi_max_vecs;//bio_vecs数目上限

structbio_vec*bi_io_vec;//bio_vec链表：内存的位置

bio_end_io_t*bi_end_io;//I/O完成方法

atomic_tbi_cnt;//使用计数

void*bi_private;//拥有者的私有方法

bio_destructor_t*bi_destructor;//销毁方法

};

intmpage_readpage(structpage*page,get_block_tget_block)

{

structbio*bio=NULL;

sector_tlast_block_in_bio=0;

structbuffer_headmap_bh;

unsignedlongfirst_logical_block=0;

map_bh.b_state=0;

map_bh.b_size=0;

bio=do_mpage_readpage(bio,page,1,&last_block_in_bio,

&map_bh,&first_logical_block,get_block);

if(bio)

mpage_bio_submit(READ,bio);

return0;

}

4.讲到这里是时候对读操作做个总结了