一个简单文件系统的实现

flike

贴出来，毕竟是这个文件系统的一部分

zenglei421

我来学习 哈哈 谢谢楼主呀
。。

zenglei421

怎么有点类似 驱动呀
哈哈
对内核不是很熟悉哈
难道 文件系统也是模块化编程里的一种？
呵呵 新手

flike

想问一下楼主，你是怎样调试这个程序的，毕竟你也不能保证第一次写出来的代码就没有错误?
学习下你的经验.

goter

我重新上传了个压缩包，里边有mkfs.gt的代码
调试的话是按albcamus老大写的教程来的，很好用，地址http://linux.chinaunix.net/bbs/v ... p%3Bfilter%3Ddigest

goter

下面我们来分析目录索引节点操作，这个应该是文件系统中最重要的地方了
在namei.c中定义

1. const struct inode_operations gt_dir_inode_operations={
   
2.         .create        =gt_create,
   
3.         .lookup        =gt_lookup,
   
4.         .link                =gt_link,
   
5.         .unlink        =gt_unlink,
   
6.         .symlink        =gt_symlink,
   
7.         .mkdir        =gt_mkdir,
   
8.         .rmdir        =gt_rmdir,
   
9.         .mknod        =gt_mknod,
   
10.         .rename        =gt_rename,
    
11. };

复制代码

先来看gt_create（在namei.c中定义）

1. static int gt_create(struct inode *dir,struct dentry *dentry,int mode,struct nameidata *nd){
   
2.         return gt_mknod(dir,dentry,mode,0);
   
3. }

复制代码

gt_create调用gt_mknod在dir中创建一个文件

gt_mknod（在namei.c中定义）

1. static int gt_mknod(struct inode *dir,struct dentry *dentry,int mode,dev_t rdev){
   
2.         int error;
   
3.         struct inode *inode;
   
4.         if(!old_valid_dev(rdev))
   
5.                 return -EINVAL;
   
6.          
   
7.         inode=gt_new_inode(dir,&error);//在dir代表的目录中新建一个索引节点
   
8.         if(inode){
   
9.                 inode->i_mode=mode;
   
10.                 gt_set_inode(inode,rdev);//根据素引节点类型，设置不同的操作
    
11.                
    
12.                 mark_inode_dirty(inode);
    
13.                 error=add_nondir(dentry,inode);//将目录项和索引节点联系起来
    
14.         }
    
15.         return error;
    
16. }

复制代码

这个函数调用了gt_new_inode，gt_set_inode，add_nondir这三个函数
先来看gt_new_inode（在inode.c中定义）

1. struct inode *gt_new_inode(struct inode *dir,int *err){
   
2. 
   
3.         struct super_block *sb;
   
4.         struct buffer_head *bh;
   
5.         ino_t ino=0;
   
6.         int block;
   
7.         struct inode *inode;
   
8. 
   
9.         struct gt_inode_info *gi;
   
10.         struct gt_inode *raw_inode;
    
11.         char *p;
    
12.        
    
13.         sb=dir->i_sb;
    
14.         inode=new_inode(sb);//调用VFS函数，VFS函数又会调用前面分析过的超级块操作中的gt_alloc_inode函数来在内存中分配一个索引节点
    
15.         if(!inode)
    
16.                 return ERR_PTR(-ENOMEM);
    
17.         gi=GT_I(inode);//获取到内存索引节点       
    
18.        
    
19.         inode->i_uid=current->fsuid;
    
20.         inode->i_gid=(dir->i_mode&S_ISGID)?dir->i_gid:current->fsgid;
    
21.         inode->i_mtime=inode->i_atime=inode->i_ctime=CURRENT_TIME_SEC;
    
22.        
    
23.         block=2;//索引节点表所在的块
    
24.         struct gt_inode *prev=NULL;
    
25.         while(bh=sb_bread(sb,block)){//遍历索引节点表
    
26.                 p=bh->b_data;
    
27.                 while(p<=(bh->b_data+GT_BLOCK_SIZE-GT_INODE_SIZE)){
    
28.                         raw_inode=(struct gt_inode *)p;
    
29.                         ino++;
    
30.                         if(!raw_inode->i_nlinks&&!raw_inode->i_start_block){//找到一个链接数为0，而且，开始块为0的磁盘索引节点
    
31.                                 if(!prev->i_reserved)//如果前一个索引节点的i_reserved为0，则设置其为默认的GT_BLOCK_RESERVED
    
32.                                         prev->i_reserved=GT_BLOCK_RESERVED;
    
33.                                 prev->i_blocks=prev->i_end_block-prev->i_start_block+1;//并且设置其i_blocks，表示该索引节点已经封顶
    
34.                        
    
35.                                 mark_buffer_dirty(bh);
    
36.                                 goto find;
    
37.                         }
    
38.                         p+=GT_INODE_SIZE;
    
39.                        
    
40.                         prev=raw_inode;
    
41.                 }
    
42.                 brelse(bh);
    
43.                 if(block>GT_INODE_BLOCK_COUNT(sb))
    
44.                         break;
    
45.                 block++;       
    
46.         }
    
47.        
    
48.         iput(inode);
    
49.         brelse(bh);
    
50.         *err=-ENOSPC;
    
51.         return NULL;
    
52. find:
    
53.         inode->i_ino=ino;
    
54.        
    
55.         raw_inode->i_start_block=prev->i_end_block+prev->i_reserved+1;//新磁盘索引节点的开始块等于前一个索引节点的结束块加上预留块
    
56.         gi->i_reserved=raw_inode->i_reserved;//根据新磁盘索引节点来设置内存索引节点
    
57.         gi->i_start_block=gi->i_end_block=raw_inode->i_start_block;
    
58.         raw_inode->i_end_block=raw_inode->i_start_block;//新磁盘索引节点的开始块等于结束块，此时并不设置i_blocks，因为这个索引节点是新建的，不需要被“封顶”
    
59.         brelse(bh);
    
60.         insert_inode_hash(inode);       
    
61.         mark_inode_dirty(inode);
    
62.         *err=0;
    
63.         return inode;
    
64. }

复制代码

然后就是gt_set_inode（在namei.c中定义）

1. void gt_set_inode(struct inode *inode,dev_t rdev){
   
2.         if(S_ISREG(inode->i_mode)){
   
3.                 inode->i_op=&gt_file_inode_operations;
   
4.                 inode->i_fop=&gt_file_operations;
   
5.                 inode->i_mapping->a_ops=&gt_aops;
   
6.         }else if(S_ISDIR(inode->i_mode)){
   
7.                 inode->i_op=&gt_dir_inode_operations;
   
8.                 inode->i_fop=&gt_dir_operations;
   
9.                 inode->i_mapping->a_ops=&gt_aops;
   
10.         }else if(S_ISLNK(inode->i_mode)){
    
11.                 inode->i_op=&gt_symlink_inode_operations;
    
12.                 inode->i_mapping->a_ops=&gt_aops;
    
13.         }else
    
14.                 init_special_inode(inode,inode->i_mode,rdev);
    
15. }
    

复制代码

这个函数函数很重要，它根据索引节点的属性，设置其对应的操作方法，从而将VFS的操作与GTFS的操作联系起来

add_nondir（在namei.c中定义）函数

1. static int add_nondir(struct dentry *dentry,struct inode *inode){
   
2.        
   
3.         int err=gt_add_link(dentry,inode);
   
4.         if(!err){
   
5.                 d_instantiate(dentry,inode);//成功的话，将dentry链入inode对应的目录项队列中（一个索引节点可以对应很多目录项）
   
6.                 return 0;       
   
7.         }
   
8.         inode_dec_link_count(inode);//如果出错，则该索引节点的链接数应该减一
   
9.         iput(inode);
   
10.         return err;
    
11. }
    

复制代码

这个函数又调用gt_add_link来将dentry对应的目录项加入父目录，然后设置目录项对应的索引节点号
下面就是gt_add_link

1. int gt_add_link(struct dentry *dentry,struct inode *inode){
   
2.         struct inode *dir=dentry->d_parent->d_inode;//获取到父目录
   
3.         const char *name=dentry->d_name.name;//目录项名称
   
4.         int namelen=dentry->d_name.len;
   
5. 
   
6.         struct page *page=NULL;
   
7.         unsigned long npages=gt_dir_pages(dir);
   
8.         unsigned long n;
   
9.         char *kaddr,*p;
   
10.         int ino;
    
11.         struct gt_dir_entry *de;
    
12.         loff_t pos;
    
13.         int err;
    
14.         char *namx=NULL;
    
15.         __u32 inumber;
    
16. 
    
17.         for(n=0;n<=npages;n++){
    
18.                 char *limit,*dir_end;
    
19.                 page=gt_get_page(dir,n);
    
20.                 err=PTR_ERR(page);
    
21.                 if(IS_ERR(page))
    
22.                         goto out;
    
23.                 lock_page(page);
    
24.                 kaddr=(char *)page_address(page);
    
25.                 dir_end=kaddr+gt_last_byte(dir,n);//在页内未使用空间的地址
    
26.                 limit=kaddr+PAGE_CACHE_SIZE-sizeof(struct gt_dir_entry);
    
27.                 for(p=kaddr;p<=limit;p=gt_next_entry(p)){
    
28.                         de=(struct gt_dir_entry *)p;
    
29.                         namx=de->name;
    
30.                         inumber=de->ino;
    
31.                         if(p==dir_end){//如果走到最后一个页的目录项结尾，则在此处插入新的目录项
    
32.                                 goto got_it;
    
33.                         }
    
34.                         if(!inumber)//如果在中途某个目录项没有被使用，对应的索引节点号为0（被删除），则跳到got_it
    
35.                                 goto got_it;
    
36. 
    
37.                         err=-EEXIST;
    
38.                         if(namecompare(namelen,GT_NAME_LEN,name,namx))
    
39.                                 goto out_unlock;
    
40.                         ino=de->ino;
    
41.                 }
    
42.                 unlock_page(page);
    
43.                 gt_put_page(page);
    
44.         }
    
45.         BUG();
    
46.         return -EINVAL;
    
47. got_it:
    
48. //准备开始写,pos为页内偏移，在pos开始处写
    
49.         pos=(page->index>>PAGE_CACHE_SHIFT)+p-(char *)page_address(page);
    
50.         err=__gt_write_begin(NULL,page->mapping,pos,sizeof(struct gt_dir_entry),AOP_FLAG_UNINTERRUPTIBLE,&page,NULL);
    
51.         if(err)
    
52.                 goto out_unlock;
    
53.         memcpy(namx,name,namelen);       
    
54.         memset(namx+namelen,0,GT_NAME_LEN-namelen-4);// 将名字数组多余的空间清空
    
55.         de->ino=inode->i_ino;//参数inode用来设置目录项对应的索引节点号
    
56.         err=gt_commit_chunk(page,pos,sizeof(struct gt_dir_entry));//提交写
    
57.         dir->i_mtime=dir->i_ctime=CURRENT_TIME_SEC;
    
58.         mark_inode_dirty(dir);
    
59. out_put:
    
60.         gt_put_page(page);
    
61. out:
    
62.         return err;
    
63. out_unlock:
    
64.         unlock_page(page);
    
65.         goto out_put;
    
66. }

复制代码

这个函数用来设置目录想的名称和对应的索引节点号，并且将目录项写入父目录的块里

goter

然后是gt_look_up（在namei.c中定义）

1. static struct dentry *gt_lookup(struct inode *dir,struct dentry *dentry,struct nameidata *nd){
   
2.         struct inode *inode=NULL;
   
3.         ino_t ino=0;
   
4.         dentry->d_op=dir->i_sb->s_root->d_op;
   
5.         if(dentry->d_name.len>GT_NAME_LEN)
   
6.                 return ERR_PTR(-ENAMETOOLONG);
   
7.         struct page *page;
   
8.        
   
9.         struct gt_dir_entry *de=gt_find_entry(dentry,&page);
   
10.         if(de){
    
11.                 ino=de->ino;
    
12.                 gt_put_page(page);       
    
13.         }
    
14.         if(ino){
    
15.                 inode=gt_iget(dir->i_sb,ino);
    
16.                 if(IS_ERR(inode))
    
17.                         return ERR_CAST(inode);
    
18.         }
    
19.         d_add(dentry,inode);
    
20.         return NULL;
    
21. }

复制代码

顾名思义，这个函数就是要在dir目录里寻找名为dentry->d_name.name的目录项，只不过这个寻找的过程由gt_find_entry完成，如果寻找到的话，则调用gt_iget，读入该目录项对应的索引节点。并且调用d_add函数将该目录项链入索引节点。

gt_find_entry（在dir.c中定义）

1. struct gt_dir_entry * gt_find_entry(struct dentry *dentry,struct page **res_page){
   
2.         const char *name=dentry->d_name.name;
   
3.         int namelen=dentry->d_name.len;
   
4.         struct inode *dir=dentry->d_parent->d_inode;//父目录
   
5.        
   
6.         unsigned long n;
   
7.         unsigned long npages=gt_dir_pages(dir);
   
8.         struct page *page=NULL;
   
9.         char *p;
   
10. 
    
11.         char *namx;
    
12.         __u32        inumber;
    
13.         *res_page=NULL;
    
14.        
    
15.         for(n=0;n<npages;n++){
    
16.                 char *kaddr,*limit;
    
17.                 page=gt_get_page(dir,n);        //获取到父目录代表文件在内存中的第n页
    
18.                 if(IS_ERR(page))
    
19.                         continue;
    
20.                 kaddr=(char *)page_address(page);
    
21.                 limit=kaddr+gt_last_byte(dir,n)-sizeof(struct gt_dir_entry);
    
22.                 for(p=kaddr;p<=limit;p=gt_next_entry(p)){
    
23.                         struct gt_dir_entry *de=(struct gt_dir_entry *)p;
    
24.                         namx=de->name;
    
25.                         inumber=de->ino;
    
26.                         if(!inumber)//如果该目录项没有被使用，跳过
    
27.                                 continue;
    
28.                         if(namecompare(namelen,GT_NAME_LEN,name,namx))//判断是否匹配
    
29.                                 goto found;//如果匹配则调到found处
    
30.                 }
    
31.                 gt_put_page(page);
    
32.         }
    
33.         return NULL;
    
34. found:
    
35.         *res_page=page;//设置参数返回值
    
36.         return (struct gt_dir_entry *)p;
    
37. }

复制代码

这段代码和我们之前看过的代码很象，都是循环遍历，所以也没什么好讲的
接下来是
gt_iget（在inode.c中定义）

1. struct inode *gt_iget(struct super_block *sb,unsigned long ino){
   
2. 
   
3.         struct gt_inode_info *gi;
   
4.         struct buffer_head *bh;
   
5.         struct gt_inode *raw_inode;
   
6.        
   
7.         long ret=-EIO;
   
8.          
   
9.         struct inode *inode=iget_locked(sb,ino);
   
10. 
    
11.         if(!inode)
    
12.                 return ERR_PTR(-ENOMEM);
    
13.         if(!(inode->i_state &I_NEW))
    
14.                 return inode;
    
15.         gi=GT_I(inode);
    
16. 
    
17.         raw_inode=gt_raw_inode(inode->i_sb,ino,&bh);
    
18.         if(!raw_inode){
    
19.                 iput(inode);
    
20.                 return NULL;
    
21.         }
    
22.        
    
23.         inode->i_mode=raw_inode->i_mode;
    
24.         inode->i_uid=(uid_t)raw_inode->i_uid;
    
25.         inode->i_gid=(gid_t)raw_inode->i_gid;
    
26.         inode->i_size=raw_inode->i_size;
    
27.         inode->i_nlink=raw_inode->i_nlinks;
    
28.         inode->i_rdev=raw_inode->i_dev;
    
29.         inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec = raw_inode->i_ctime;
    
30.         inode->i_mtime.tv_nsec = 0;
    
31.         inode->i_atime.tv_nsec = 0;
    
32.         inode->i_ctime.tv_nsec = 0;
    
33. 
    
34.         gi->i_dtime=raw_inode->i_dtime;
    
35. 
    
36.         if(inode->i_nlink==0 && (inode->i_mode==0||gi->i_dtime)){
    
37.                
    
38.                 brelse(bh);
    
39.                 ret=-ESTALE;
    
40.                 goto bad_inode;
    
41.         }
    
42. 
    
43.         inode->i_blocks=raw_inode->i_blocks;
    
44.         gi->i_dtime=0;
    
45.         gi->i_start_block=raw_inode->i_start_block;
    
46.         gi->i_end_block=raw_inode->i_end_block;
    
47.         gi->i_blocks=raw_inode->i_blocks;
    
48.         gi->i_reserved=raw_inode->i_reserved;
    
49. 
    
50.         gt_set_inode(inode,inode->i_rdev);
    
51.         brelse(bh);
    
52.         unlock_new_inode(inode);
    
53.        
    
54.         return inode;
    
55. bad_inode:
    
56.         iget_failed(inode);
    
57.         return ERR_PTR(ret);
    
58. }

复制代码

这个函数首先调用iget_locked来在内存中寻找超级块sb中索引节点号是ino的索引节点，如果找到就返回，如果找不到就在内存中分配一个inode结构，并且设置其索引节点号和状态，如果iget_locked返回的VFS索引节点的状态为新，说明这个VFS索引节点是在iget_locked中新分配的，需要从磁盘读入磁盘索引节点来填充VFS索引节点和内存索引节点,于是接着调用gt_raw_inode，对VFS索引节点和内存索引节点进行设置，于是，这个函数通过参数指定的超级块和索引节点号，返回在代表这个索引节点的VFS索引节点

[ 本帖最后由 goter 于 2009-5-24 08:40 编辑 ]

flike

楼主，谢谢你分享自己的作品！但有时候想改一下代码，并调试一下不知怎么弄。有时间的话请把你的内核调试环境搭建及调试方法写出来。让大家学习一下。

liuty2006

关注

yuanzcbbs

多谢lz共享，文件数据的磁盘组织格式是什么？