Chinaunix首页 | 论坛 | 博客

wangcong02345wangcong02345.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

wangcong02345

  • 博客访问： 2150801
  • 博文数量： 438
  • 博客积分： 3871
  • 博客等级： 中校
  • 技术积分： 6075
  • 用 户 组： 普通用户
  • 注册时间： 2011-09-10 00:11
个人简介

邮箱: wangcong02345@163.com

文章分类

全部博文（438）

文章存档

2017年（15）

2016年（119）

2015年（91）

2014年（62）

2013年（56）

2012年（79）

2011年（16）

我的朋友
最近访客
推荐博文
相关博文
linux0.12--11.minix文件系统中文件读取流程

分类： LINUX

2016-10-09 15:54:02

文件系统如下:
  1. cong@msi:/tmp/minix$ tree
  2. .
  3. ├── bin
  4. │   ├── init
  5. │   ├── ls
  6. │   ├── sh
  7. │   └── sh_ok
  8. ├── dev
  9. │   └── tty1
  10. ├── etc
  11. ├── usr
  12. │   └── bin
  13. └── var

  15. 6 directories, 5 files
  16. cong@msi:/tmp/minix$ ls -l bin/
  17. total 548
  18. -rwxr-xr-x 1 root root 7293 Oct 5 00:13 init
  19. -rwxr-xr-x 1 root root 46084 Jan 15 1992 ls
  20. -rwx--x--x 1 root root 250880 Feb 28 2004 sh
  21. -rwxr-xr-x 1 root root 250880 Oct 5 00:22 sh_ok
  22. cong@msi:/tmp/minix$ ls -l dev/
  23. total 0
  24. crw-r--r-- 1 root root 4, 1 Oct 5 00:13 tty1
init --> (void) open("/dev/tty1",O_RDWR,0);
a.看路径的首字符是不是/，判断是相对路径还是绝对路径，绝对路径是从root的inode开始找
b. 通过读root的inode的数据块，里面是一堆dir_entry,看有没有跟dev这个nam匹配的，
   若有则返回dev的inode_nr,即dir_entry中的inode_nr
c.有了dev的inode_nr，读取dev的inode
d.有了dev的inode就可以读取dev的数据块，因为dev是一个目录，再查找目录里面有没有跟tty1匹配的name
  若有则返回tty1的inode_nr,即dir_entry中的inode_nr
f. 有了tty1的inode_nr,就可以读取tty1中的数据，这儿是一个设备文件，只有一个设备号存在i_zone[0]中

1. 在fs/open.c中
  1. int sys_open(const char * filename,int flag,int mode)
  2. {
  3.     struct m_inode * inode;
  4.     struct file * f;
  5.     int i,fd;

  7.     mode &= 0777 & ~current->umask;
  8. //在fd表中选一个没有用的,现在一个都没有用，所以fd=0
  9.     for(fd=0 ; fd<NR_OPEN ; fd++)
  10.         if (!current->filp[fd])
  11.             break;
  12.     if (fd>=NR_OPEN)
  13.         return -EINVAL;
  14.     current->close_on_exec &= ~(1<<fd);
  15. //在file_table中选一个没有使用的
  16.     f=0+file_table;
  17.     for (i=0 ; i<NR_FILE ; i++,f++)
  18.         if (!f->f_count) break;
  19.     if (i>=NR_FILE)
  20.         return -EINVAL;
  21. //将fip[fd]与file_table中的项挂接
  22.     (current->filp[fd]=f)->f_count++;
  23. //获取filename的inode,以后进行read write操作都是靠inode来的
  24.     if ((i=open_namei(filename,flag,mode,&inode))<0) {
  25.         current->filp[fd]=NULL;
  26.         f->f_count=0;
  27.         return i;
  28.     }
  29. /* ttys are somewhat special (ttyxx major==4, tty major==5) */
  30.     if (S_ISCHR(inode->i_mode))
  31.         if (check_char_dev(inode,inode->i_zone[0],flag)) {
  32.             iput(inode);
  33.             current->filp[fd]=NULL;
  34.             f->f_count=0;
  35.             return -EAGAIN;
  36.         }
  37. /* Likewise with block-devices: check for floppy_change */
  38.     if (S_ISBLK(inode->i_mode))
  39.         check_disk_change(inode->i_zone[0]);
  40.     f->f_mode = inode->i_mode;
  41.     f->f_flags = flag;
  42.     f->f_count = 1;
  43.     f->f_inode = inode;       //保存这个filename指定的inode,以后read write就靠这个inode了
  44.     f->f_pos = 0;
  45.     return (fd);
  46. }

2. 在fs/namei.c中
(pathname=0x226b0 "/dev/tty1", flag=2, mode=0, res_inode=0xffffb0) at namei.c:390
  1. int open_namei(const char * pathname, int flag, int mode,
  2.     struct m_inode ** res_inode)
  3. {
  4.     const char * basename;
  5.     int inr,dev,namelen;
  6.     struct m_inode * dir, *inode;
  7.     struct buffer_head * bh;
  8.     struct dir_entry * de;

  10.     if ((flag & O_TRUNC) && !(flag & O_ACCMODE))
  11.         flag |= O_WRONLY;
  12.     mode &= 0777 & ~current->umask;
  13.     mode |= I_REGULAR;
  14.     if (!(dir = dir_namei(pathname,&namelen,&basename,NULL)))  //d.有了dev的inode就可以读取dev的数据块
  15.         return -ENOENT;
  16.     if (!namelen) {            /* special case: '/usr/' etc */
  17.         if (!(flag & (O_ACCMODE|O_CREAT|O_TRUNC))) {
  18.             *res_inode=dir;
  19.             return 0;
  20.         }
  21.         iput(dir);
  22.         return -EISDIR;
  23.     }
  24.     bh = find_entry(&dir,basename,namelen,&de);                 //因为dev是一个目录，再查找目录里面有没有跟tty1匹配的name,
  25.     if (!bh) {                                                   //若有则返回tty1的inode_nr,即dir_entry中的inode_nr
  26.         if (!(flag & O_CREAT)) {
  27.             iput(dir);
  28.             return -ENOENT;
  29.         }
  30.         if (!permission(dir,MAY_WRITE)) {
  31.             iput(dir);
  32.             return -EACCES;
  33.         }
  34.         inode = new_inode(dir->i_dev);
  35.         if (!inode) {
  36.             iput(dir);
  37.             return -ENOSPC;
  38.         }
  39.         inode->i_uid = current->euid;
  40.         inode->i_mode = mode;
  41.         inode->i_dirt = 1;
  42.         bh = add_entry(dir,basename,namelen,&de);
  43.         if (!bh) {
  44.             inode->i_nlinks--;
  45.             iput(inode);
  46.             iput(dir);
  47.             return -ENOSPC;
  48.         }
  49.         de->inode = inode->i_num;
  50.         bh->b_dirt = 1;
  51.         brelse(bh);
  52.         iput(dir);
  53.         *res_inode = inode;
  54.         return 0;
  55.     }
  56.     inr = de->inode;
  57.     dev = dir->i_dev;
  58.     brelse(bh);
  59.     if (flag & O_EXCL) {
  60.         iput(dir);
  61.         return -EEXIST;
  62.     }
  63.     if (!(inode = follow_link(dir,iget(dev,inr))))
  64.         return -EACCES;
  65.     if ((S_ISDIR(inode->i_mode) && (flag & O_ACCMODE)) ||
  66.      !permission(inode,ACC_MODE(flag))) {
  67.         iput(inode);
  68.         return -EPERM;
  69.     }
  70.     inode->i_atime = CURRENT_TIME;
  71.     if (flag & O_TRUNC)
  72.         truncate(inode);
  73.     *res_inode = inode;
  74.     return 0;
  75. }

在fs/namei.c中
  1. static struct m_inode * dir_namei(const char * pathname,
  2.     int * namelen, const char ** name, struct m_inode * base)
  3. {
  4.     char c;
  5.     const char * basename;
  6.     struct m_inode * dir;

  8.     if (!(dir = get_dir(pathname,base)))
  9.         return NULL;
  10.     basename = pathname;
  11.     while (c=get_fs_byte(pathname++))
  12.         if (c=='/')
  13.             basename=pathname;
  14.     *namelen = pathname-basename-1;
  15.     *name = basename;
  16.     return dir;
  17. }


在fs/namei.c中
  1. static struct m_inode * get_dir(const char * pathname, struct m_inode * inode)
  2. {
  3.     char c;
  4.     const char * thisname;
  5.     struct buffer_head * bh;
  6.     int namelen,inr;
  7.     struct dir_entry * de;
  8.     struct m_inode * dir;
  9. //如果pathname第1个字符不是/则是相对路径从pwd开始找，如果第1个字符是/则是绝对路径从root开始找
  10.     if (!inode) {
  11.         inode = current->pwd;                   //默认是从pwd开始查找
  12.         inode->i_count++;
  13.     }
  14.     if ((c=get_fs_byte(pathname))=='/') {
  15.         iput(inode);
  16.         inode = current->root;                 //当知道第1个字符是/时，则从root开始查找
  17.         pathname++;                            //pathname="dev/tty1"
  18.         inode->i_count++;
  19.     }
  20.     while (1) {
  21.         thisname = pathname;                   //thisname = pathname="dev/tty1"
  22.         if (!S_ISDIR(inode->i_mode) || !permission(inode,MAY_EXEC)) {
  23.             iput(inode);
  24.             return NULL;
  25.         }
  26.         for(namelen=0;(c=get_fs_byte(pathname++))&&(c!='/');namelen++)
  27.             /* nothing */ ;                        //for完后: pathname="tty1",thisname="dev/tty1"
  28.         if (!c)
  29.             return inode;
  30.         if (!(bh = find_entry(&inode,thisname,namelen,&de))) {
  31.             iput(inode);
  32.             return NULL;
  33.         }
  34.         inr = de->inode;
  35.         brelse(bh);
  36.         dir = inode;
  37.         if (!(inode = iget(dir->i_dev,inr))) {     //读取dev的inode
  38.             iput(dir);
  39.             return NULL;
  40.         }
  41.         if (!(inode = follow_link(dir,inode)))
  42.             return NULL;
  43.     }
  44. }
在fs/namei.c中
find_entry需要保证第1个参数的属性是目录
第1次进这个find_entry时,dir就是root的inode
搜索该目录inode的所有数据块，看有没有匹配名字的dir_entry,如果有则将结查保存在res_dir中
这个目的是为了得到name的inode_nr
  1. static struct buffer_head * find_entry(struct m_inode ** dir,
  2.     const char * name, int namelen, struct dir_entry ** res_dir)
  3. {
  4.     int entries;
  5.     int block,i;
  6.     struct buffer_head * bh;
  7.     struct dir_entry * de;
  8.     struct super_block * sb;

  10. #ifdef NO_TRUNCATE
  11.     if (namelen > NAME_LEN)
  12.         return NULL;
  13. #else
  14.     if (namelen > NAME_LEN)
  15.         namelen = NAME_LEN;
  16. #endif
  17. //在当前目录下有多少项
  18.     entries = (*dir)->i_size / (sizeof (struct dir_entry));
  19.     *res_dir = NULL;
  20. /* check for '..', as we might have to do some "magic" for it */
  21.     if (namelen==2 && get_fs_byte(name)=='.' && get_fs_byte(name+1)=='.') {
  22. /* '..' in a pseudo-root results in a faked '.' (just change namelen) */
  23.         if ((*dir) == current->root)
  24.             namelen=1;
  25.         else if ((*dir)->i_num == ROOT_INO) {
  26. /* '..' over a mount-point results in 'dir' being exchanged for the mounted
  27.    directory-inode. We set mounted, so that we can iput the new dir */
  28.             sb=get_super((*dir)->i_dev);
  29.             if (sb->s_imount) {
  30.                 iput(*dir);
  31.                 (*dir)=sb->s_imount;
  32.                 (*dir)->i_count++;
  33.             }
  34.         }
  35.     }
  36. //先读取该目录inode的第1个数据块
  37.     if (!(block = (*dir)->i_zone[0]))
  38.         return NULL;
  39.     if (!(bh = bread((*dir)->i_dev,block)))
  40.         return NULL;
  41.     i = 0;
  42.     de = (struct dir_entry *) bh->b_data;
  43. //搜索该目录inode的所有数据块，去匹配要查找的name，找到之后就把inode_nr保存在res_dir中
  44.     while (i < entries) {
  45.         if ((char *)de >= BLOCK_SIZE+bh->b_data) {   //如果第1个数据块中没有name,则读取并查找下一个数据块
  46.             brelse(bh);
  47.             bh = NULL;
  48.             if (!(block = bmap(*dir,i/DIR_ENTRIES_PER_BLOCK)) ||
  49.              !(bh = bread((*dir)->i_dev,block))) {
  50.                 i += DIR_ENTRIES_PER_BLOCK;
  51.                 continue;
  52.             }
  53.             de = (struct dir_entry *) bh->b_data;
  54.         }
  55.         if (match(namelen,name,de)) {
  56.             *res_dir = de;              //如果找到了就将结果保存在res_dir中
  57.             return bh;                  //res_dir中最重要的是inode_nr
  58.         }
  59.         de++;
  60.         i++;
  61.     }
  62.     brelse(bh);
  63.     return NULL;
  64. }
二.sys_read
2.1 在fs/read_write.c中
  1. int sys_read(unsigned int fd,char * buf,int count)
  2. {
  3.     struct file * file;
  4.     struct m_inode * inode;

  6.     if (fd>=NR_OPEN || count<0 || !(file=current->filp[fd]))
  7.         return -EINVAL;
  8.     if (!count)
  9.         return 0;
  10.     verify_area(buf,count);
  11.     inode = file->f_inode;
  12.     if (inode->i_pipe)
  13.         return (file->f_mode&1)?read_pipe(inode,buf,count):-EIO;
  14.     if (S_ISCHR(inode->i_mode))
  15.         return rw_char(READ,inode->i_zone[0],buf,count,&file->f_pos);
  16.     if (S_ISBLK(inode->i_mode))
  17.         return block_read(inode->i_zone[0],&file->f_pos,buf,count);
  18. //如果是目录或者是普通文件的话
  19.     if (S_ISDIR(inode->i_mode) || S_ISREG(inode->i_mode)) {      
  20.         if (count+file->f_pos > inode->i_size)
  21.             count = inode->i_size - file->f_pos;
  22.         if (count<=0)
  23.             return 0;
  24.         return file_read(inode,file,buf,count);
  25.     }
  26.     printk("(Read)inode->i_mode=%06o\n\r",inode->i_mode);
  27.     return -EINVAL;
  28. }
2.2 在fs/file_dev.c中
  1. int file_read(struct m_inode * inode, struct file * filp, char * buf, int count)
  2. {
  3.     int left,chars,nr;
  4.     struct buffer_head * bh;

  6.     if ((left=count)<=0)
  7.         return 0;
  8.     while (left) {
  9.         if (nr = bmap(inode,(filp->f_pos)/BLOCK_SIZE)) {    //通过i_zone[0-8]找出下一步要读取的block_nr
  10.             if (!(bh=bread(inode->i_dev,nr)))               //将block_nr中的数据读取出来
  11.                 break;
  12.         } else
  13.             bh = NULL;
  14.         nr = filp->f_pos % BLOCK_SIZE;
  15.         chars = MIN( BLOCK_SIZE-nr , left );
  16.         filp->f_pos += chars;
  17.         left -= chars;
  18.         if (bh) {
  19.             char * p = nr + bh->b_data;
  20.             while (chars-->0)
  21.                 put_fs_byte(*(p++),buf++);
  22.             brelse(bh);
  23.         } else {
  24.             while (chars-->0)
  25.                 put_fs_byte(0,buf++);
  26.         }
  27.     }
  28.     inode->i_atime = CURRENT_TIME;
  29.     return (count-left)?(count-left):-ERROR;
  30. }
2.3  在fs/inode.c中
  1. int bmap(struct m_inode * inode,int block)
  2. {
  3.     return _bmap(inode,block,0);
  4. }
2.4  在fs/inode.c中
block是filp->f_pos,即文件的偏移，例如: 文件长度是10K,读取从8K开始的字节，则block=8
  1. static int _bmap(struct m_inode * inode,int block,int create)
  2. {
  3.     struct buffer_head * bh;
  4.     int i;
  5. //1个block是1K字节,先判断block是否大于一次间接块与二次间接块所能表示的最大长度
  6.     if (block<0)
  7.         panic("_bmap: block<0");
  8.     if (block >= 7+512+512*512)      //一次间接块最大能表示512K,二次间接块512*512K
  9.         panic("_bmap: block>big");
  10. //如果block<7，i_zone[0-6]就可以表示块号了
  11.     if (block<7) {
  12.         if (create && !inode->i_zone[block])
  13.             if (inode->i_zone[block]=new_block(inode->i_dev)) {
  14.                 inode->i_ctime=CURRENT_TIME;
  15.                 inode->i_dirt=1;
  16.             }
  17.         return inode->i_zone[block];     //不需要索引就找到了要读取的block_nr=i_zone[0-6]中就放着下一步要读取的块号
  18.     }
  19. //如果block>7,先减去7,看剩下的用一次间接块能不能全部表示出来
  20.     block -= 7;
  21.     if (block<512) {
  22.         if (create && !inode->i_zone[7])
  23.             if (inode->i_zone[7]=new_block(inode->i_dev)) {
  24.                 inode->i_dirt=1;
  25.                 inode->i_ctime=CURRENT_TIME;
  26.             }
  27.         if (!inode->i_zone[7])
  28.             return 0;
  29.         if (!(bh = bread(inode->i_dev,inode->i_zone[7])))   //i_zone[7]中就放着一次间接块的块号
  30.             return 0;
  31.         i = ((unsigned short *) (bh->b_data))[block];       
  32.         if (create && !i)
  33.             if (i=new_block(inode->i_dev)) {
  34.                 ((unsigned short *) (bh->b_data))[block]=i;
  35.                 bh->b_dirt=1;
  36.             }
  37.         brelse(bh);
  38.         return i;                                          //1次索引完后就找到了要读取的block_nr
  39.     }
  40. //如果一次间接块搞不定，这就需要用到二次间接块
  41.     block -= 512;
  42.     if (create && !inode->i_zone[8])
  43.         if (inode->i_zone[8]=new_block(inode->i_dev)) {
  44.             inode->i_dirt=1;
  45.             inode->i_ctime=CURRENT_TIME;
  46.         }
  47.     if (!inode->i_zone[8])
  48.         return 0;
  49.     if (!(bh=bread(inode->i_dev,inode->i_zone[8])))       //i_zone[8]中就放着二次间接块的块号
  50.         return 0;
  51.     i = ((unsigned short *)bh->b_data)[block>>9];         //第1次索引
  52.     if (create && !i)
  53.         if (i=new_block(inode->i_dev)) {
  54.             ((unsigned short *) (bh->b_data))[block>>9]=i;
  55.             bh->b_dirt=1;
  56.         }
  57.     brelse(bh);
  58.     if (!i)
  59.         return 0;
  60.     if (!(bh=bread(inode->i_dev,i)))
  61.         return 0;
  62.     i = ((unsigned short *)bh->b_data)[block&511];       //第2次索引
  63.     if (create && !i)
  64.         if (i=new_block(inode->i_dev)) {
  65.             ((unsigned short *) (bh->b_data))[block&511]=i;
  66.             bh->b_dirt=1;
  67.         }
  68.     brelse(bh);
  69.     return i;                                           //2次索引完后就找到了要读取的block_nr
  70. }

阅读(1204) | 评论(0) | 转发(0) |
0

上一篇：linux0.12--10.minix文件系统分析

下一篇： linux0.12--12.自己写的解析minix硬盘镜像的小工具

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6