一个简单文件系统的实现

goter

/*转载请注明作者
author goter
email prowlman@gmail.com
*/
花了将进两个月的时候阅读完内核文件系统，对于文件系统是如何运行的还是有点模糊，所以想通过写一个简单的文件系统来使自己对文件系统有个深入的了解。经过拷贝抄袭ext2和minix文件系统后，写了一个简单的文件系统，我把这个简单的文件系统叫作GTFS，估计还有很多BUG，欢迎大家修正这些BUG
GTFS不支持磁盘配额和acl。链接，读写，删除，新建，改名等都支持，有时候会有莫名其妙的错误，希望大家谅解

下面先附上代码和使用信息

使用信息
在fs/Makefile中添加一行

1. 
   
2. obj-$(CONFIG_GT_FS)                += gt/
   

复制代码

在fs/Kconfig中添加

1. 
   
2. config GT_FS
   
3.         tristate "GOTER fs support"
   
4.         help
   
5.            GTFS is a simple Linux file system for hard disk.
   

复制代码

在include/linux/Kbuild中添加一行

1. 
   
2. unifdef-y += gt_fs.h
   

复制代码

在include/linux/magic.h中添加一行

1. 
   
2. #define GT_SUPER_MAGIC                0x0601
   

复制代码

为了迎接六一儿童节，所以GTFS的魔数就设为0x0601了

然后将附件中的压缩包解压，可以看到有两个目录
一个目录是mkfs.gt,进入mkfs.gt目录，里边有4个文件，mkfs.gt为生成的二进制文件，可以使用gcc -o mkfs.gt mkfs.gt.c生成mkfs.gt工具，这个工具用来创建GT文件系统，只支持mkfs.gt /dev/sdax（设备名）命令。
另一个目录是gtfs，进入gtfs目录，里边有8个文件，将gtfs/gt_fs.h移动到内核include/linux/下，然后在内核fs/ 下新建目录gt,将剩余的7个文件移动到gt下

然后make menuconfig，到filesystem下选中gtfs，然后编译即可

GT-FS.tar.gz (19.69 KB, 下载次数: 1808)

2009-05-23 20:17 上传

点击文件名下载附件

我会在下面为大家分析GTFS代码的

[ 本帖最后由 goter 于 2009-5-23 20:17 编辑 ]

goter

因为GTFS只是用来学习而不是用于生产环境的，所以GTFS的设计很简单也很简陋。GTFS的主要数据结构和其他文件系统相似，主要的区别是组织块的方式
下面是GTFS的主要数据结构
gt_inode(索引节点，在gt_fs.h中定义)

1. struct gt_inode {
   
2. __le16 i_mode;
   
3. __le16 i_uid;
   
4. __le16 i_gid;
   
5. __le32 i_size;
   
6. __le32 i_atime;
   
7. __le32 i_ctime;
   
8. __le32 i_mtime;
   
9. __le32 i_dtime;
   
10. __le16 i_nlinks;
    
11. __le32 i_flags;
    
12. __le32 i_start_block;//索引节点开始块
    
13. __le32 i_end_block;//素引节点结束块
    
14. __le32 i_blocks;//索引节点占用的块数，另外作为索引节点是否是最后一个的flag
    
15. __le16 i_dev;
    
16. __le32 i_reserved;//为该索引节点预留的块数
    
17. __u8 i_nouse[10];
    
18. }

复制代码

很简单是吧，i_blocks的用途有点特别，GTFS默认每个索引节点都会占用一个块，所以新建一个索引节点时，i_start_block=i_end_block，但此时i_blocks和i_reserved为0，因为GTFS对磁盘的使用是顺序使用的，所以当新建一个索引节点时，上一个索引节点就需要设置下预留块数，以便文件的增长。新建的索引节点的开始块等于结束块，但并不需要设置预留块数，因为它可以一直使用到最后一个磁盘块（它没有下一个索引节点，我管这叫没有封顶），那么当操作系统打开一个文件时，如何判断这个文件对应的索引节点是不是新建的呢，这就是i_blocks的作用，当i_blocks为0时，说明这个索引节点是新建的。当新建一个索引节点时，会设置上一个索引节点的i_blocks,

1. i_blocks=i_end_blocks-i_start_blocks+1

复制代码

所以，每个索引节点都至少占用一个块


gt_inode_info(内存中的i节点信息，在gt.h中定义)

1. struct gt_inode_info{
   
2. __le32 i_start_block;
   
3. __le32 i_end_block;
   
4. __le32 i_blocks;
   
5. __le32 i_reserved;
   
6. __u32 i_flags;
   
7. __u32 i_dtime;
   
8. struct mutex truncate_mutex;
   
9. struct inode vfs_inode;
   
10. };

复制代码

gt_super_block(超级块，在gt_fs.h中定义)

1. struct gt_super_block {
   
2. __le32 s_inodes_count;
   
3. __le16 s_inode_size;
   
4. __le32 s_blocks_count;
   
5. __le32 s_free_blocks_count;
   
6. __le32 s_free_inodes_count;
   
7. __le32 s_first_data_block;
   
8. __le32 s_first_ino;
   
9. __le32 s_link_max;
   
10. __le32 s_log_block_size;
    
11. __le32 s_mtime;
    
12. __le32 s_wtime;
    
13. __le16 s_magic;
    
14. };

复制代码

超级块数据结构没什么特别的，超级块的内容在挂载文件系统时从磁盘超级块读入

gt_sb_info（内存中的超级块，在gt_fs.h中定义）

1. struct  gt_sb_info{
   
2. struct gt_super_block * s_gs;//指向GT文件系统的超级块
   
3. struct buffer_head * s_sbh;//指向超级块所在的缓冲区
   
4. };

复制代码

gt_dir_entry（目录项，在gt_fs.h中定义）

1. #define GT_NAME_LEN 60 //目录项名字长度
   
2. struct gt_dir_entry {
   
3. __le32 ino;
   
4. char name[GT_NAME_LEN];
   
5. };

复制代码

goter

文件系统的实现还需要对超级块的操作，对文件的操作，索引节点操作等等
我们就先从挂载一个文件系统开始
挂载文件系统时候，VFS会通过mount命令中的文件系统类型或超级块魔数来寻找file_system_type结构
下面就是GTFS的file_system_type结构（定义在super.c中）

1. static struct file_system_type gt_fs_type ={
   
2.         .owner                =THIS_MODULE,
   
3.         .name                ="gt",//文件系统名称
   
4.         .get_sb                =gt_get_sb,//读取超级块方法
   
5.         .kill_sb        =kill_block_super,
   
6.         .fs_flags        =FS_REQUIRES_DEV,        
   
7. };

复制代码

我们只需要完成gt_get_sb(定义在super.c中)方法即可

1. static int gt_get_sb(struct file_system_type *fs_type,
   
2. int flags,const char *dev_name,void *data,struct vfsmount *mnt){
   
3.         return get_sb_bdev(fs_type,flags,dev_name,data,gt_fill_super,mnt);
   
4. }

复制代码

从gt_get_sb函数可以看出，这个函数调用了get_sb_bdev函数，get_sb_bdev又调用了gt_fill_super函数
gt_fill_super函数才是正真用来读取超级块的方法

1. static int gt_fill_super(struct super_block *sb,void *data,int silent){
   
2. 
   
3.         struct buffer_head *bh;
   
4.         struct gt_super_block *gs;
   
5.         struct gt_sb_info *sbi;
   
6.         struct inode *root;//设备的根目录
   
7.         
   
8.         unsigned long sb_block=1;//超级块的块号为1，第0块为启动块
   
9. 
   
10.         long ret=-EINVAL;
    
11.         
    
12.         int blocksize=BLOCK_SIZE;//BLOCK_SIZE为1024
    
13. 
    
14.         sbi=kzalloc(sizeof(struct gt_sb_info),GFP_KERNEL);
    
15.         if(!sbi)
    
16.                 return -ENOMEM;
    
17. 
    
18.         if(!sb_set_blocksize(sb,BLOCK_SIZE))//设置VFS超级块的块大小
    
19.                 goto out_bad_hblock;
    
20.         if(!(bh=sb_bread(sb,sb_block))){//将GTFS超级块所在的块读入内存
    
21.                 printk("GT-fs:unable to read superblock\n");
    
22.                 goto failed_sbi;
    
23.         }
    
24. 
    
25.         gs=(struct gt_super_block *)(bh->b_data);
    
26.         sbi->s_sbh=bh;//指向从磁盘读入的GTFS超级块所在的缓冲区
    
27.         sbi->s_gs=gs;//将内存中的GTFS超级块和从磁盘读入的GTFS超级块联系起来
    
28.         sb->s_fs_info=sbi;//将VFS超级块和GTFS的超级块联系起来
    
29.         sb->s_magic=gs->s_magic;//设置魔数
    
30. 
    
31.         if(sb->s_magic !=GT_SUPER_MAGIC)
    
32.                 goto cantfind_gt;
    
33. 
    
34.         blocksize=GT_BLOCK_SIZE;
    
35. 
    
36.         sb->s_op=&gt_sops;
    
37.         
    
38.         root=gt_iget(sb,GT_ROOT_INO);//GT_ROOT_INO为1，读入文件系统的根目录
    
39.         if(IS_ERR(root)){
    
40.                 ret=PTR_ERR(root);
    
41.                 printk(KERN_ERR "GT-fs: can't find root inode\n");
    
42.                 goto failed_mount;        
    
43.         }
    
44.         if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
    
45.                 iput(root);
    
46.                 printk(KERN_ERR "isdir?%d,root->i_blocks=%d,root->i_size=%d\n",S_ISDIR(root->i_mode) , root->i_blocks, root->i_size);
    
47.                 printk(KERN_ERR "GT-fs: corrupt root inode\n");
    
48.                 goto failed_mount;
    
49.         }
    
50. 
    
51.         sb->s_root = d_alloc_root(root);//设置超级块的根目录
    
52.         if (!sb->s_root) {
    
53.                 iput(root);
    
54.                 printk(KERN_ERR "GT: get root inode failed\n");
    
55.                 ret = -ENOMEM;
    
56.                 goto failed_mount;
    
57.         }
    
58.         
    
59.         return 0;
    
60. cantfind_gt:
    
61.         printk("VFS: Can't find an gt filesystem on dev %s.\nmagic on dev is %d and magic of GT is %d\n",sb->s_id,sb->s_magic,GT_SUPER_MAGIC);
    
62. failed_mount:
    
63.         brelse(bh);
    
64. out_bad_hblock:
    
65.         printk("GT-fs:blocksize too small for device\n");
    
66. failed_sbi:
    
67.         sb->s_fs_info=NULL;
    
68.         kfree(sbi);
    
69.         return ret;
    
70. }

复制代码

这段函数主要是从磁盘读入文件系统的超级块，用来填充内存中的GTFS超级块，和VFS超级块
调用gt_iget函数读入指定文件系统的根目录。

goter

文件系统在kernel中被当作一个模块实现
也有module_init和module_exit(定义在super.c)

1. module_init(init_gt_fs)
   
2. module_exit(exit_gt_fs)

复制代码

init_gt_fs（定义在super.c）

1. static int __init init_gt_fs(void){
   
2.     int err=init_inodecache();
   
3.     if(err)
   
4.        return err;
   
5.     err=register_filesystem(&gt_fs_type);//向内核注册GT文件系统
   
6.     if(err)
   
7.        goto out;
   
8.     return 0;
   
9. out:
   
10.     destroy_inodecache();
    
11.     return err;
    
12. }

复制代码

init_gt_fs中调用init_inodecache创建GTFS的内存索引节点缓冲池（我瞎猜的...对这个不了解..）

init_inodecache（定义在super.c中）

1. static struct kmem_cache *gt_inode_cachep;
   
2. static int init_inodecache(void){
   
3.    gt_inode_cachep=kmem_cache_create("gt_inode_cache",sizeof(struct gt_inode_info),0,(SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD),init_once);
   
4.    if(gt_inode_cachep==NULL)
   
5.       return -ENOMEM;
   
6.    return 0;
   
7. }

复制代码

然后就是exit_gt_fs（定义在super.c中）

1. static void __exit exit_gt_fs(void){
   
2.      unregister_filesystem(&gt_fs_type);//注销文件系统
   
3.      destroy_inodecache();//销毁缓冲池
   
4. }

复制代码

[ 本帖最后由 goter 于 2009-5-23 14:49 编辑 ]

goter

接下来是超级块操作（定义在super.c中）

1. static const struct super_operations gt_sops={
   
2.         .alloc_inode        =gt_alloc_inode,//分配一个GTFS的索引节点
   
3.         .destroy_inode        =gt_destroy_inode,//销毁索引节点
   
4.         .write_inode        =gt_write_inode,//写入索引节点
   
5.         .delete_inode        =gt_delete_inode,//删除索引节点
   
6.         .write_super    =gt_write_super,//将超级块写入磁盘
   
7.         .put_super        =gt_put_super,//释放超级块
   
8.         .statfs                =gt_statfs,//获取文件系统状态
   
9.         .write_inode        =gt_write_inode,//将索引节点写入磁盘
   
10. };

复制代码

下面我们挨个介绍
gt_alloc_inode（定义在super.c中）

1. static struct inode *gt_alloc_inode(struct super_block *sb){
   
2.         struct gt_inode_info *gi;
   
3. 
   
4.         gi=(struct gt_inode_info *)kmem_cache_alloc(gt_inode_cachep,GFP_KERNEL);//在缓冲池分配一个GTFS的内存索引节点
   
5.         if(!gi)
   
6.                 return NULL;
   
7.         return &gi->vfs_inode;
   
8. }

复制代码

函数gt_destroy_inode（定义在super.c中）

1. static void gt_destroy_inode(struct inode *inode){
   
2.         kmem_cache_free(gt_inode_cachep,GT_I(inode));
   
3. }

复制代码

从缓冲池中释放GTFS的内存中索引节点
GT_I是定义在gt.h中的一个inline函数，根据VFS索引节点返回GTFS的内存索引节点

1. static inline struct gt_inode_info *GT_I(struct inode *inode){
   
2.           return container_of(inode,struct gt_inode_info,vfs_inode);
   
3. }

复制代码

然后是gt_write_inode(定义在super.c中)

1. static int gt_write_inode(struct inode *inode,int wait){
   
2.         brelse(gt_update_inode(inode));
   
3.         return 0;
   
4. }

复制代码

可见，gt_write_inode函数调用gt_update_inode来将内存中的索引节点写入磁盘

gt_update_inode(定义在inode.c中)

1. struct buffer_head *gt_update_inode(struct inode *inode){
   
2.                
   
3.         struct gt_inode_info *gi=GT_I(inode);
   
4.         struct super_block *sb=inode->i_sb;
   
5.         ino_t ino=inode->i_ino;
   
6.         uid_t uid=inode->i_uid;
   
7.         gid_t gid=inode->i_gid;
   
8.         struct buffer_head *bh;
   
9.         struct gt_inode *raw_inode =gt_raw_inode(sb,ino,&bh);//根据超级块和索引节点号从磁盘读入GTFS的磁盘索引节点
   
10. 
    
11.         if(!raw_inode)
    
12.                 return NULL;
    
13.         /*更新*/
    
14.         raw_inode->i_mode=inode->i_mode;
    
15.         raw_inode->i_uid=uid;
    
16.         raw_inode->i_gid=gid;
    
17.         raw_inode->i_nlinks=inode->i_nlink;
    
18.         raw_inode->i_size=inode->i_size;
    
19.         raw_inode->i_atime=inode->i_atime.tv_sec;
    
20.         raw_inode->i_mtime=inode->i_mtime.tv_sec;
    
21.         raw_inode->i_ctime=inode->i_ctime.tv_sec;
    
22.         //raw_inode->i_dtime=inode->i_dtime.tv_sec;
    
23.        
    
24.         if(S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
    
25.                 raw_inode->i_dev=old_encode_dev(inode->i_rdev);
    
26.         else{
    
27.                 raw_inode->i_start_block=gi->i_start_block;
    
28.                 raw_inode->i_end_block=gi->i_end_block;
    
29.                 raw_inode->i_blocks=gi->i_blocks;
    
30.                 raw_inode->i_reserved=gi->i_reserved;
    
31.                        
    
32.         }
    
33.         mark_buffer_dirty(bh);//将磁盘索引节点所在的缓冲块标记为脏
    
34.         return bh;
    
35. }

复制代码

gt_update_inode很简单，通过调用gt_raw_inode来读入GTFS的磁盘索引节点，然后根据GTFS内存索引节点去设置磁盘索引节点，最后将磁盘索引节点所在的缓冲块标记为脏，等待机会写入磁盘。gt_raw_inode将在后面介绍，我们回到超级块操作来

接下来是gt_delete_inode（定义在super.c中）

1. static void gt_delete_inode(struct inode *inode){
   
2.         truncate_inode_pages(&inode->i_data,0);
   
3.         GT_I(inode)->i_dtime=get_seconds();
   
4.         inode->i_size=0;
   
5.         gt_truncate(inode);//清空文件
   
6.         gt_free_inode(inode);//释放索引节点
   
7. }

复制代码

让我们来看看gt_truncate（定义在inode.c中）

1. void gt_truncate(struct inode *inode){
   
2.         if(!(S_ISREG(inode->i_mode)||S_ISDIR(inode->i_mode)||S_ISLNK(inode->i_mode)))
   
3.                 return;
   
4.         struct gt_inode_info *gi=GT_I(inode);
   
5.         block_truncate_page(inode->i_mapping,inode->i_size,gt_get_block);
   
6. 
   
7.         gi->i_reserved+=gi->i_end_block-gi->i_start_block+1;//设置预留块数
   
8.         gi->i_end_block=gi->i_start_block;//清空
   
9.         inode->i_mtime=inode->i_ctime=CURRENT_TIME_SEC;
   
10.         mark_inode_dirty(inode);
    
11. }

复制代码

这个函数主要是设置内存索引节点的块使用状况

还有gt_free_inode(定义在inode.c中)

1. void gt_free_inode(struct inode *inode){
   
2.         struct super_block *sb=inode->i_sb;
   
3.         struct gt_super_block *gs=GT_SB(inode->i_sb)->s_gs;
   
4.         struct buffer_head *bh;
   
5.         unsigned long ino;
   
6.         ino=inode->i_ino;
   
7.         struct gt_inode *raw_inode=NULL;
   
8.         if(ino<1||ino>gs->s_inodes_count){
   
9.                 printk("gt_free_inode: inode 0 or nonexistent inode\n");
   
10.                 return;
    
11.         }
    
12.         raw_inode=gt_raw_inode(sb,ino,&bh);
    
13.         if(raw_inode){
    
14.                 raw_inode->i_nlinks=0;//设置磁盘索引节点的连接数
    
15.                 raw_inode->i_mode=0;
    
16.         }
    
17.         if(bh){
    
18.                 mark_buffer_dirty(bh);
    
19.                 brelse(bh);
    
20.         }
    
21.         clear_inode(inode);//调用VFS函数清理VFS索引节点
    
22. }

复制代码

这个函数也很简单，只是读取磁盘索引节点，然后设置连接数和模式，然后标记磁盘索引节点所在的缓冲块为脏

goter

接着写超级块操作
接下来就是gt_write_super（定义在super.c中）

1. static int gt_write_super(struct super_block *sb){
   
2.         struct gt_super_block *gs;
   
3.         lock_kernel();
   
4.         gs=GT_SB(sb)->s_gs;
   
5.         gs->s_free_blocks_count=cpu_to_le32(gt_count_free_blocks(sb));
   
6.         gs->s_free_inodes_count=cpu_to_le32(gt_count_free_inodes(sb));
   
7.         gs->s_mtime=cpu_to_le32(get_seconds());
   
8.         gs->s_wtime = cpu_to_le32(get_seconds());
   
9.         mark_buffer_dirty(GT_SB(sb)->s_sbh);
   
10.         sync_dirty_buffer(GT_SB(sb)->s_sbh);
    
11.         sb->s_dirt=0;       
    
12.         unlock_kernel();
    
13. }

复制代码

这个很简单很简单，简单到我都懒的讲了..
让我们来看看gt_count_free_blocks和gt_count_free_inodes
这俩函数都定义在inode.c中

1. unsigned long gt_count_free_inodes(struct super_block *sb){
   
2.         struct buffer_head *bh;
   
3.         struct gt_inode *gt;
   
4.         char *p;
   
5.          
   
6.         unsigned long block=2; //索引节点表所在块
   
7.         unsigned long count=0;//使用了的索引节点数
   
8.         //然后遍历索引节点表
   
9.         while(bh=sb_bread(sb,block)){
   
10.                 p=bh->b_data;
    
11.                 while(p<=(bh->b_data+GT_BLOCK_SIZE-GT_INODE_SIZE)){
    
12.                         gt=(struct gt_inode *)p;
    
13.                         if(gt->i_nlinks)
    
14.                                 count++;//已经使用的索引节点数加一
    
15.                         p+=GT_INODE_SIZE;
    
16.                 }
    
17.                 brelse(bh);
    
18.                 if(block>GT_INODE_BLOCK_COUNT(sb))//如果到了索引节点表结尾则跳出
    
19.                         break;
    
20.                 block++;       
    
21.         }
    
22.        
    
23.         return GT_SB(sb)->s_gs->s_inodes_count-count;//返回未使用的索引节点数
    
24. }

复制代码

1. unsigned long gt_count_free_blocks(struct super_block *sb){
   
2. 
   
3.         struct gt_super_block *gs;
   
4.         char *p;
   
5.         int block=2;
   
6.         gs=GT_SB(sb)->s_gs;
   
7.         unsigned long used=0;//已经使用的块数
   
8.         struct buffer_head *bh;
   
9.         struct gt_inode * gt;
   
10.        //遍历索引节点表，已经使用的块数其实就等于最后一个索引节点的i_end_block
    
11.         while(bh=sb_bread(sb,block)){
    
12.                 p=bh->b_data;
    
13.                 while(p<=(bh->b_data+GT_BLOCK_SIZE-GT_INODE_SIZE)){
    
14.                         gt=(struct gt_inode *)p;
    
15.                         if(!gt->i_blocks)
    
16.                                 used=gt->i_end_block;
    
17.                                
    
18.                 }
    
19.                 brelse(bh);
    
20.         }
    
21.         return GT_BLOCKS(sb)-used;
    
22. }

复制代码

goter

gt_put_super(定义在super.c中)

1. static void gt_put_super(struct super_block *sb){
   
2.         struct gt_sb_info *sbi=GT_SB(sb);
   
3.         brelse(sbi->s_sbh);
   
4.         sb->s_fs_info=NULL;
   
5.         kfree(sbi);
   
6. }

复制代码

这个函数释放掉磁盘超级块所在的缓冲块，释放掉内存超级块

gt_statfs(定义在super.c中)

1. static int gt_statfs(struct dentry *dentry,struct kstatfs *buf){
   
2.         struct gt_sb_info * sbi=GT_SB(dentry->d_sb);
   
3.         struct gt_super_block *gs=sbi->s_gs;
   
4.         buf->f_type=dentry->d_sb->s_magic;
   
5.         buf->f_bsize=dentry->d_sb->s_blocksize;
   
6.         buf->f_blocks=(gs->s_blocks_count-gs->s_first_data_block);
   
7.         buf->f_bfree=gt_count_free_blocks(sbi);
   
8.         buf->f_bavail=buf->f_bfree;
   
9.         buf->f_ffree=gt_count_free_inodes(sbi);
   
10.         buf->f_namelen=GT_NAME_LEN;
    
11.         return 0;
    
12. }

复制代码

这个函数获取文件系统状态

到这里超级块的操作就完成了，接下来是普通索引节点操作，只需要一个清空函数，其他的调用vfs默认的函数

1. const struct inode_operations gt_file_inode_operations ={
   
2.         .truncate        =gt_truncate,
   
3. };

复制代码

[ 本帖最后由 goter 于 2009-5-23 15:03 编辑 ]

goter

普通文件操作(在file.c中定义)，只需要实现一个gt_sync_file

1. const struct file_operations gt_file_operations ={
   
2.         .llseek                =generic_file_llseek,
   
3.         .read                =do_sync_read,
   
4.         .write                =do_sync_write,
   
5.         .aio_read        =generic_file_aio_read,
   
6.         .aio_write        =generic_file_aio_write,
   
7.         .mmap                =generic_file_mmap,
   
8.         .open                =generic_file_open,
   
9.         .fsync                =gt_sync_file,
   
10. };

复制代码

来看看gt_sync_file(在file.c中定义)

1. int gt_sync_file(struct file *file,struct dentry *dentry,int datasync){
   
2.         struct inode *inode =dentry->d_inode;
   
3.         int err,ret;
   
4.         ret=sync_mapping_buffers(inode->i_mapping);
   
5.         if(!(inode->i_state&I_DIRTY))
   
6.                 return ret;
   
7.         if(datasync && !(inode->i_state&I_DIRTY_DATASYNC))
   
8.                 return ret;
   
9.         err=gt_sync_inode(inode);
   
10.         if(ret==0)
    
11.                 ret=err;
    
12.         return ret;
    
13. }
    

复制代码

函数调用gt_sync_inode(在inode.c中定义)

1. int gt_sync_inode(struct inode *inode){
   
2.         int ret=0;
   
3.         struct buffer_head *bh;
   
4.         bh=gt_update_inode(inode);//获取到磁盘索引节点所在的缓冲区
   
5.         if(bh && buffer_dirty(bh)){//如果为脏，则同步
   
6.                 sync_dirty_buffer(bh);
   
7.                 if(buffer_req(bh)&&!buffer_uptodate(bh)){
   
8.                         printk("IO error syncing gt inode\n");
   
9.                         ret=-1;
   
10.                 }
    
11.         }else if(!bh)
    
12.                 ret=-1;
    
13.         brelse(bh);
    
14.         return ret;
    
15. }

复制代码

[ 本帖最后由 goter 于 2009-5-23 15:09 编辑 ]

goter

未完待续

Godbach

多谢LZ分享，改天有时间编译一下源码，试用一下。