[关闭]
@harpsword 2015-11-26T06:37:58.000000Z 字数 14737 阅读 2348

文件系统底层操作函数部分之三(inode.c)

文件系统

简述

该程序主要包括住了i节点的函数 i_get()、input()和块映射函数 bmap(),以及一些辅助函数。

i_get()

用于从设备dev上读取指定节点号nr的i节点，并且把i节点的引用计数字段值i_count增1.操作流程如下图。

操作流程

iput()

所完成的功能正好与 iget() 相反，它主要用于把i节点引用计数值递减1，即 相当于该进程释放该i节点或文件，然后根据 该i节点的类型选择相应的动作。

若该i节点是:

在执行过以下操作之一后，内核通常应该调用 iput() 函数
1. 把i节点引用计数字段 i_count 的值增 1
2. 调用了 namei()、dir_namei()或open_namei()函数
3. 调用了 iget()、new_inode()或get_empty_inode()函数
4. 在关闭一个文件时，若已经没有其他进程使用该文件
5. 卸载一个文件系统时(需要放回设备文件名i节点等)

另外，一个进程被创建时，其当前工作目录 pwd、进程当前根目录root和可执行文件目录executable三个i节点结构指针字段都会被初始化而指向这三个i节点，并且也相应的设置了这三个i节点的引用计数字段。因此，当进程执行改变当前工作目录的系统调用时，在该系统调用的代码中就需要调用 input()函数来先放回使用的i节点，然后再设置pwd。 对于 root和 executable也一样。

bmap()

bmap()函数:把一个文件数据块映射到盘块的处理操作。或者说是对i节点的逻辑块(区块)数组i_zone[]进行处理，并且根据i_zone[]中所设置的逻辑块号来设置逻辑块位图对应bit位。

参数说明:

一些理解

内存中i节点表表项

代码分析

宏定义

  1. // 这是get_pipe_inode()函数中使用的，表示 inode.i_zone[0] 存储管道头指针
  2. // inode.i_zone[1] 存储管道尾指针
  3. #define PIPE_HEAD(inode) ((inode).i_zone[0]) 
  4. #define PIPE_TAIL(inode) ((inode).i_zone[1])

一些重要数据结构定义

struct m_inode inode_table[NR_INODE]={{0,},};

函数分析

常用的函数如下

重要的函数如下

这个函数有两种情况，

  1. bmap()
  1. int bmap(struct m_inode * inode,int block)
  2. {
  3.     return _bmap(inode,block,0);
  4. }
  1. create_block()
  1. int create_block(struct m_inode * inode, int block)
  2. {
  3.     return _bmap(inode,block,1);
  4. }

代码区

  1. /*
  2.  *  linux/fs/inode.c
  3.  *
  4.  *  (C) 1991  Linus Torvalds
  5.  */
  7. #include <string.h> 
  8. #include <sys/stat.h>
  10. #include <linux/sched.h>
  11. #include <linux/kernel.h>
  12. #include <linux/mm.h>
  13. #include <asm/system.h>
  15. // 内存中i节点表(NR_INODE=32)
  16. struct m_inode inode_table[NR_INODE]={{0,},};
  18. // 读指定i节点号的i节点信息
  19. static void read_inode(struct m_inode * inode);
  20. // 写i节点信息到高速缓冲中
  21. static void write_inode(struct m_inode * inode);
  23. // 类似 wait_on_buffer(struct buffer_head * bh)
  24. //// 等待指定的i节点可用
  25. // 如果i节点已被锁定，则将当前任务置为不可中断的等待状态，并添加到该
  26. // i节点的等待队列i_wait中。直到该i节点解锁并明确地唤醒本地任务。
  27. static inline void wait_on_inode(struct m_inode * inode)
  28. {
  29.     cli();
  30.     while (inode->i_lock)
  31.         sleep_on(&inode->i_wait);
  32.     sti();
  33. }
  35. //// 对指定的i节点上锁(锁定指定的i节点)
  36. // 如果i节点已被锁定，则将当前任务置为不可中断的等待状态，并添加到该
  37. // i节点的等待队列i_wait中，直到该i节点解锁并明确地唤醒本地任务。然后对其上锁。
  39. // 跟当前任务有个毛关系啊? 根本没有看到 current 变量(当前任务指针)
  40. static inline void lock_inode(struct m_inode * inode)
  41. {
  42.     cli();
  43.     while (inode->i_lock)
  44.         sleep_on(&inode->i_wait);
  45.     inode->i_lock=1;
  46.     sti();
  47. }
  49. //// 对指定的i节点解锁
  50. // 复位i节点的锁定标志，并明确地唤醒等待在此i节点等待i_wait上的所有进程。
  51. static inline void unlock_inode(struct m_inode * inode)
  52. {
  53.     inode->i_lock=0;
  54.     wake_up(&inode->i_wait);
  55. }
  57. //// 释放设备dev在内存i节点表中的所有i节点
  58. // 扫描内存中的i节点表数组，如果是指定设备使用的i节点就释放之。
  59. void invalidate_inodes(int dev)
  60. {
  61.     int i;
  62.     struct m_inode * inode;
  64.     // 首先让指针指向内存i节点表数组首项。然后扫描i节点表指针数组中的所有i
  65.     // 节点。针对其中每个i节点，先等待该i节点解锁可用，再判断是否属于指定设备
  66.     // 的i节点。如果是指定设备的i节点，则看看它是否还被使用着，即其引用计数
  67.     // 是否不为0.若是则显示警告信息。然后释放之，即把i节点的设备号字段i_dev置0.
  68.     inode = 0+inode_table;                      // 指向i节点表指针数组首项
  69.     for(i=0 ; i<NR_INODE ; i++,inode++) {
  70.         wait_on_inode(inode);  // 是否必须要等待其解锁????
  71.         if (inode->i_dev == dev) {
  72.             if (inode->i_count)
  73.                 printk("inode in use on removed disk\n\r");
  74.             inode->i_dev = inode->i_dirt = 0;
  75.         }
  76.     }
  77. }
  79. //// 同步所有i节点
  80. // 把内存i节点表中所有i节点与设备上i节点作同步操作
  81. void sync_inodes(void)
  82. {
  83.     int i;
  84.     struct m_inode * inode;
  86.     // 首先让内存i节点类型的指针指向i节点表首项，然后扫描整个i节点表中的节点。针对
  87.     // 其中每个i节点，先等待该i节点解锁可用(若目前正被上锁的话)，然后判断该i节点
  88.     // 是否已被修改并且不是管道节点。若是这种情况则将该i节点写入高速缓冲区中。
  89.     // 缓冲区管理程序buffer.c会在适当时机将他们写入盘中。
  90.     inode = 0+inode_table;
  91.     for(i=0 ; i<NR_INODE ; i++,inode++) {
  92.         wait_on_inode(inode);
  93.         if (inode->i_dirt && !inode->i_pipe)
  94.             write_inode(inode);
  95.     }
  96. }
  98. //// 文件数据块映射到盘块的处理操作。（block位图处理函数，bmap - block map）
  99. // 参数：inode - 文件的i节点指针；block - 文件中的数据块号；create - 创建块标志。
  100. // 该函数把指定的文件数据块block对应到设备上逻辑块上，并返回逻辑块号。如果创建标志
  101. // 置位，则在设备上对应逻辑块不存在时就申请新磁盘块，返回文件数据块block对应在设备
  102. // 上的逻辑块号（盘块号）。
  103. static int _bmap(struct m_inode * inode,int block,int create)
  104. {
  105.     struct buffer_head * bh;
  106.     int i;
  108.     // 首先判断参数文件数据块号block的有效性。如果块号小于0，则停机。如果块号大于
  109.     // 直接块数+间接块数+二次间接块数，超出文件系统表示范围，则停机。
  110.     if (block<0)
  111.         panic("_bmap: block<0");
  112.     if (block >= 7+512+512*512)
  113.         panic("_bmap: block>big");
  114.     // 然后根据文件块号的大小值和是否设置了创建标志分别进行处理。如果该块号小于7，
  115.     // 则使用直接块表示。如果创建标志置位，并且i节点中对应块的逻辑块(区段)字段为0，
  116.     // 则相应设备申请一磁盘块（逻辑块），并且将磁盘上逻辑块号（盘块号）填入逻辑块
  117.     // 字段中。然后设置i节点改变时间，置i节点已修改标志。然后返回逻辑块号。
  118.     if (block<7) {
  119.         if (create && !inode->i_zone[block])
  120.             if ((inode->i_zone[block]=new_block(inode->i_dev))) {
  121.                 inode->i_ctime=CURRENT_TIME;
  122.                 inode->i_dirt=1;
  123.             }
  124.         return inode->i_zone[block];
  125.     }
  126.     // 如果该块号>=7,且小于7+512，则说明使用的是一次间接块。下面对一次间接块进行处理。
  127.     // 如果是创建，并且该i节点中对应间接块字段i_zone[7]是0，表明文件是首次使用间接块，
  128.     // 则需申请一磁盘块用于存放间接块信息，并将此实际磁盘块号填入间接块字段中。然后
  129.     // 设置i节点修改标志和修改时间。如果创建时申请磁盘块失败，则此时i节点间接块字段
  130.     // i_zone[7] = 0,则返回0.或者不创建，但i_zone[7]原来就为0，表明i节点中没有间接块，
  131.     // 于是映射磁盘是吧，则返回0退出。
  132.     block -= 7;
  133.     if (block<512) {
  134.         if (create && !inode->i_zone[7])
  135.             if ((inode->i_zone[7]=new_block(inode->i_dev))) {
  136.                 inode->i_dirt=1;
  137.                 inode->i_ctime=CURRENT_TIME;
  138.             }
  139.         if (!inode->i_zone[7])
  140.             return 0;
  141.         // 现在读取设备上该i节点的一次间接块。并取该间接块上第block项中的逻辑块号（盘块
  142.         // 号）i。每一项占2个字节。如果是创建并且间接块的第block项中的逻辑块号为0的话，
  143.         // 则申请一磁盘块，并让间接块中的第block项等于该新逻辑块块号。然后置位间接块的
  144.         // 已修改标志。如果不是创建，则i就是需要映射（寻找）的逻辑块号。
  145.         if (!(bh = bread(inode->i_dev,inode->i_zone[7])))
  146.             return 0;
  147.         i = ((unsigned short *) (bh->b_data))[block];
  148.         if (create && !i)
  149.             if ((i=new_block(inode->i_dev))) {
  150.                 ((unsigned short *) (bh->b_data))[block]=i;
  151.                 bh->b_dirt=1;
  152.             }
  153.         // 最后释放该间接块占用的缓冲块，并返回磁盘上新申请或原有的对应block的逻辑块号。
  154.         brelse(bh);
  155.         return i;
  156.     }
  157.     // 若程序运行到此，则表明数据块属于二次间接块。其处理过程与一次间接块类似。下面是对
  158.     // 二次间接块的处理。首先将block再减去间接块所容纳的块数(512)，然后根据是否设置了
  159.     // 创建标志进行创建或寻找处理。如果是新创建并且i节点的二次间接块字段为0，则序申请一
  160.     // 磁盘块用于存放二次间接块的一级信息，并将此实际磁盘块号填入二次间接块字段中。之后，
  161.     // 置i节点已修改标志和修改时间。同样地，如果创建时申请磁盘块失败，则此时i节点二次
  162.     // 间接块字段i_zone[8]为0，则返回0.或者不是创建，但i_zone[8]原来为0，表明i节点中没有
  163.     // 间接块，于是映射磁盘块失败，返回0退出。
  164.     block -= 512;
  165.     if (create && !inode->i_zone[8])
  166.         if ((inode->i_zone[8]=new_block(inode->i_dev))) {
  167.             inode->i_dirt=1;
  168.             inode->i_ctime=CURRENT_TIME;
  169.         }
  170.     if (!inode->i_zone[8])
  171.         return 0;
  172.     // 现在读取设备上该i节点的二次间接块。并取该二次间接块的一级块上第 block/512 项中
  173.     // 的逻辑块号i。如果是创建并且二次间接块的一级块上第 block/512 项中的逻辑块号为0的
  174.     // 话，则需申请一磁盘块(逻辑块)作为二次间接块的二级快i，并让二次间接块的一级块中
  175.     // 第block/512 项等于二级块的块号i。然后置位二次间接块的一级块已修改标志。并释放
  176.     // 二次间接块的一级块。如果不是创建，则i就是需要映射的逻辑块号。
  177.     if (!(bh=bread(inode->i_dev,inode->i_zone[8])))
  178.         return 0;
  179.     i = ((unsigned short *)bh->b_data)[block>>9];
  180.     if (create && !i)
  181.         if ((i=new_block(inode->i_dev))) {
  182.             ((unsigned short *) (bh->b_data))[block>>9]=i;
  183.             bh->b_dirt=1;
  184.         }
  185.     brelse(bh);
  186.     // 如果二次间接块的二级块块号为0，表示申请磁盘块失败或者原来对应块号就为0，则返回
  187.     // 0退出。否则就从设备上读取二次间接块的二级块，并取该二级块上第block项中的逻辑块号。
  188.     if (!i)
  189.         return 0;
  190.     if (!(bh=bread(inode->i_dev,i)))
  191.         return 0;
  192.     i = ((unsigned short *)bh->b_data)[block&511];
  193.     // 如果是创建并且二级块的第block项中逻辑块号为0的话，则申请一磁盘块（逻辑块），作为
  194.     // 最终存放数据信息的块。并让二级块中的第block项等于该新逻辑块块号(i)。然后置位二级块
  195.     // 的已修改标志。
  196.     if (create && !i)
  197.         if ((i=new_block(inode->i_dev))) {
  198.             ((unsigned short *) (bh->b_data))[block&511]=i;
  199.             bh->b_dirt=1;
  200.         }
  201.     // 最后释放该二次间接块的二级块，返回磁盘上新申请的或原有的对应block的逻辑块号。
  202.     brelse(bh);
  203.     return i;
  204. }
  206. //// 取文件数据块block在设备上对应的逻辑块号。
  207. // 参数：inode - 文件的内存i节点指针；block - 文件中的数据块号。
  208. // 若操作成功则返回对应的逻辑块号，否则返回0.
  209. int bmap(struct m_inode * inode,int block)
  210. {
  211.     return _bmap(inode,block,0);
  212. }
  214. //// 取文件数据块block在设备上对应的逻辑块号。
  215. // 如果对应的逻辑块不存在就创建一块。返回设备上对应的已存在或新建的逻辑块号。
  216. // 参数：inode - 文件内存i节点指针；block - 文件中的数据块号。
  217. int create_block(struct m_inode * inode, int block)
  218. {
  219.     return _bmap(inode,block,1);
  220. }
  222. //// 放回(放置)一个i节点引用计数值递减1，并且若是管道i节点，则唤醒等待的进程。
  223. // 若是块设备文件i节点则刷新设备。并且若i节点的链接计数为0，则释放该i节点占用
  224. // 的所有磁盘逻辑块，并释放该i节点。
  225. // 操作的是块设备
  226. void iput(struct m_inode * inode)
  227. {
  228.     // 首先判断参数给出的i节点的有效性，并等待inode节点解锁，如果i节点的引用计数
  229.     // 为0，表示该i节点已经是空闲的。内核再要求对其进行放回操作，说明内核中其他
  230.     // 代码有问题。于是显示错误信息并停机。
  231.     if (!inode)
  232.         return;
  233.     wait_on_inode(inode);
  234.     if (!inode->i_count)
  235.         panic("iput: trying to free free inode");
  236.     // 如果是管道i节点，则唤醒等待该管道的进程，引用次数减1，如果还有引用则返回。
  237.     // 否则释放管道占用的内存页面，并复位该节点的引用计数值、已修改标志和管道标志，
  238.     // 并返回。对于管道节点，inode->i_size存放这内存也地址。
  239.     if (inode->i_pipe) {
  240.         wake_up(&inode->i_wait);
  241.         if (--inode->i_count)
  242.             return;
  243.         free_page(inode->i_size);// 对于管道节点，inode->i_size存放内存页地址
  244.         inode->i_count=0;
  245.         inode->i_dirt=0;
  246.         inode->i_pipe=0;
  247.         return;
  248.     }
  249.     // 如果i节点对应的设备号 ＝ 0，则将此节点的引用计数递减1，返回。例如用于管道
  250.     // 操作的i节点，其i节点的设备号为0.
  251.     if (!inode->i_dev) {
  252.         inode->i_count--;
  253.         return;
  254.     }
  255.     // 如果是块设备文件的i节点，此时逻辑块字段0(i_zone[0])中是设备号，则刷新该设备。
  256.     // 并等待i节点解锁。
  257.     if (S_ISBLK(inode->i_mode)) {
  258.         // sync_dev(inode->i_dev); 觉得应该使用这一句
  259.         sync_dev(inode->i_zone[0]);
  260.         wait_on_inode(inode);
  261.     }
  262.     // 如果i节点的引用计数大于1，则计数递减1后就直接返回(因为该i节点还有人在用，不能
  263.     // 释放)，否则就说明i节点的引用计数值为1。如果i节点的链接数为0，则说明i节点对应文件
  264.     // 被删除。于是释放该i节点的所有逻辑块，并释放该i节点。函数free_inode()用于实际释
  265.     // 放i节点操作，即复位i节点对应的i节点位图bit位，清空i节点结构内容。
  266. repeat:
  267.     if (inode->i_count>1) {
  268.         inode->i_count--;
  269.         return;
  270.     }
  271.     // 下面开始 删除该i节点的所有逻辑块，但是是在 inode->i_nlinks = 0的条件下
  272.     if (!inode->i_nlinks) {
  273.         truncate(inode);  // 删除文件
  274.         free_inode(inode); // 释放i节点
  275.         return;
  276.     }
  277.     // 这里表示没有删除该i节点后的操作
  278.     // 如果该i节点已做过修改，则回写更新该i节点，并等待该i节点解锁。由于这里在写i节点
  279.     // 时需要等待睡眠，此时其他进程有可能修改i节点，因此在进程被唤醒后需要再次重复进行
  280.     // 上述判断过程(repeat)。
  281.     if (inode->i_dirt) {
  282.         write_inode(inode); /* we can sleep - so do again */
  283.         wait_on_inode(inode);
  284.         goto repeat;
  285.     }
  286.     // 程序若能执行到此，则说明该i节点的引用计数值i_count是1、链接数不为零，并且内容
  287.     // 没有被修改过。因此此时只要把i节点引用计数递减1，返回。此时该i节点的i_count=0,
  288.     // 表示已释放。 在内存中i节点已经被释放，或者可以认为是空闲状态。
  289.     inode->i_count--;
  290.     return;
  291. }
  293. //// 从i节点表(inode_table)中获取一个空闲i节点项。
  294. // 寻找引用计数count为0的i节点，并将其写盘后清零，返回指针。引用计数被置1.
  295. struct m_inode * get_empty_inode(void)
  296. {
  297.     struct m_inode * inode;
  298.     static struct m_inode * last_inode = inode_table;
  299.     int i;
  301.     do {
  302.         // 在初始化last_inode指针指向i节点表头一项后循环扫描整个i节点表。如果last_inode
  303.         // 已经指向i节点表的最后一项之后，则让其重新指向i节点表开始处，以继续循环寻找空闲
  304.         // i节点项。如果last_inode所指向的i节点的计数值为0，则说明可能找到空闲i节点项。
  305.         // 让inode指向该i节点。如果该i节点的已修改标志和锁定标志均为0，则我们可以使用该i
  306.         // 节点，于是退出for循环。
  307.         inode = NULL;
  308.         for (i = NR_INODE; i ; i--) {
  309.             if (++last_inode >= inode_table + NR_INODE)
  310.                 last_inode = inode_table;
  311.             if (!last_inode->i_count) {
  312.                 inode = last_inode;
  313.                 if (!inode->i_dirt && !inode->i_lock)
  314.                 // 找到了需要的i节点
  315.                     break;
  316.             }
  317.         }
  318.         // 如果没有找到空闲i节点（inode=NULL）,则将i节点表打印出来供调试使用，并停机。
  319.         if (!inode) {
  320.             for (i=0 ; i<NR_INODE ; i++)
  321.                 printk("%04x: %6d\t",inode_table[i].i_dev,
  322.                     inode_table[i].i_num);
  323.             panic("No free inodes in mem");
  324.         }
  325.         // 等待该i节点解锁，如果该i节点已修改标志被置位的话，则将该i节点刷新，因为刷新时
  326.         // 可能会睡眠，因此需要再次循环等待该i节点解锁。
  327.         wait_on_inode(inode);
  328.         while (inode->i_dirt) {
  329.             write_inode(inode);
  330.             wait_on_inode(inode);
  331.         }
  332.         // 如果i节点又被其他占用的话(i节点的计数值不为0了)，则重新寻找空闲i节点。否则
  333.         // 说明已找到符合要求的空闲i节点项。则将该i节点项内容清零，并置引用计数为1，
  334.         // 返回该i节点指针。
  335.     } while (inode->i_count);
  336.     memset(inode,0,sizeof(*inode)); // 清零
  337.     inode->i_count = 1;
  338.     return inode;
  339. }
  341. //// 获取管道节点。
  342. // 首先扫描i节点表，寻找一个空闲i节点项，然后取得一页空闲内存供管道使用。然后将得
  343. // 到的i节点的引用计数置为2，初始化管道头和尾，置i节点的管道类型表示。
  344. // 返回为i节点指针，如果失败则返回NULL。
  345. struct m_inode * get_pipe_inode(void)
  346. {
  347.     struct m_inode * inode;
  349.     // 首先从内存i节点表中取得一个空闲i节点。如果找不到空闲i节点则返回NULL。然后为
  350.     // 该i节点申请一页内存，并让节点的i_size字段指向该页面。如果已没有空闲内存，
  351.     // 则释放该i节点，并返回NULL
  352.     if (!(inode = get_empty_inode()))
  353.         return NULL;
  354.     if (!(inode->i_size=get_free_page())) {
  355.         inode->i_count = 0;
  356.         return NULL;
  357.     }
  358.     // 然后设置该i节点的引用计数为2，并复位管道头尾指针。i节点逻辑块号数组i_zone[]
  359.     // 的i_zone[0]和i_zone[1]中分别用来存放管道头和管道尾指针。最后设置i节点是管
  360.     // 道i节点标志并返回该i节点号。
  361.     inode->i_count = 2; /* sum of readers/writers */
  362.     // 
  363.     PIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
  364.     inode->i_pipe = 1;
  365.     return inode;
  366. }
  368. //// 获得一个i节点，从设备上读取
  369. // 参数：dev - 设备号； nr - i 节点号。
  370. // 从设备上读取指定节点号i节点到内存i节点表中，并返回该i节点指针。
  371. // 首先在位于高速缓冲区中的i节点表中搜寻，若找到指定节点号的i节点则在经过一些判断
  372. // 处理后返回该i节点指针。否则从设备dev上读取指定i节点号的i节点信息放入i节点表中，
  373. // 并返回该i节点指针。
  374. struct m_inode * iget(int dev,int nr)
  375. {
  376.     struct m_inode * inode, * empty;
  378.     // 首先判断参数的有效性。若设备号是0，则表明内核代码有问题，显示出错信息并停机。
  379.     // 然后预先从i节点表中取一个空闲i节点备用。
  380.     if (!dev)
  381.         panic("iget with dev==0");
  382.     empty = get_empty_inode();
  383.     // 接着扫描i节点表。寻找参数指定节点号nr的i节点。并递增该节点的引用次数。如果当
  384.     // 前扫描i节点的设备号不等于指定的设备号或者节点号不等于指定的节点号，则继续扫描。
  385.     inode = inode_table;
  386.     while (inode < NR_INODE+inode_table) {
  387.         if (inode->i_dev != dev || inode->i_num != nr) {
  388.             inode++;
  389.             continue;
  390.         }
  391.         // 如果找到指定设备号dev和节点号nr的i节点，则等待该节点解锁。在等待该节点解
  392.         // 锁过程中，i节点表可能会发生变化。所以再次进行上述相同判断。如果发生了变化，
  393.         // 则再次重新扫描整个i节点表。
  394.         wait_on_inode(inode);
  395.         if (inode->i_dev != dev || inode->i_num != nr) {
  396.             inode = inode_table;
  397.             continue;
  398.         }
  399.         // 到这里表示找到相应的i节点。于是将该i节点引用计数增1.然后再做进一步检查，看它
  400.         // 是否是另一个文件系统的安装点。若是则寻找被安装文件系统根节点并返回。如果
  401.         // 该i节点的确是其他文件系统的安装点，则在超级块表中搜寻安装在此i节点的超级块。
  402.         // 如果没有找到，则显示出错信息，并放回本函数开始时获取的空闲节点empty，
  403.         // 返回该i节点指针。
  404.         inode->i_count++;
  405.         if (inode->i_mount) {
  406.             int i;
  408.             for (i = 0 ; i<NR_SUPER ; i++)
  409.                 if (super_block[i].s_imount==inode)
  410.                     break;
  411.             if (i >= NR_SUPER) {
  412.                 printk("Mounted inode hasn't got sb\n");
  413.                 if (empty)
  414.                     iput(empty);
  415.                 return inode;
  416.             }
  417.             // 执行到这里表示已经找到安装到inode节点的文件系统超级块。于是将该i节点写盘
  418.             // 放回，并从安装在次i节点上的文件系统超级块中取设备号，并令i节点号为ROOT_INO，
  419.             // 即为1.然后重新扫描整个i节点表，以获取该被安装文件系统的根i节点信息。
  420.             iput(inode);
  421.             dev = super_block[i].s_dev;
  422.             nr = ROOT_INO;
  423.             inode = inode_table;
  424.             continue;
  425.         }
  426.         // 最终我们找到了相应的i节点。因此可以放弃本函数开始处临时申请的空闲的i节点，返回
  427.         // 找到的i节点指针。
  428.         if (empty)
  429.             iput(empty);
  430.         return inode;
  431.     }
  432.     // 如果我们在i节点表中没有找到指定的i节点，则利用前面申请的空闲i节点empty在i节点表中
  433.     // 建立该i节点。并从相应设备上读取该i节点信息，返回该i节点指针。
  434.     if (!empty)
  435.         return (NULL);
  436.     inode=empty;
  437.     inode->i_dev = dev;
  438.     inode->i_num = nr;
  439.     read_inode(inode);
  440.     return inode;
  441. }
  443. //// 读取指定i节点信息。
  444. // 从设备上读取含有指定i节点信息的i节点盘块，然后复制到指定的i节点结构中。为了确定i节点
  445. // 所在的设备逻辑块号（或缓冲块），必须首先读取相应设备上的超级块，以获取用于计算逻辑
  446. // 块号的每块i节点数信息INODES_PER_BLOCK.在计算出i节点所在的逻辑块号后，就把该逻辑块读入
  447. // 一缓冲块中。然后把缓冲块中相应位置处的i节点内容复制到参数指定的位置处。
  448. static void read_inode(struct m_inode * inode)
  449. {
  450.     struct super_block * sb;
  451.     struct buffer_head * bh;
  452.     int block;
  454.     // 首先锁定该i节点，并取该节点所在设备的超级块。
  455.     lock_inode(inode);
  456.     if (!(sb=get_super(inode->i_dev)))
  457.         panic("trying to read inode without dev");
  458.     // 该i节点所在的设备逻辑块号＝（启动块+超级块）+i节点位图占用的块数+逻辑块位图占用的块数
  459.     // +（i节点号-1）/每块含有的i节点数。虽然i节点号从0开始编号，但第i个0号i节点不用，并且
  460.     // 磁盘上也不保存对应的0号i节点结构。因此存放i节点的盘块的第i块上保存的是i节点号是1--16
  461.     // 的i节点结构而不是0--15的。因此在上面计算i节点号对应的i节点结构所在盘块时需要减1，即：
  462.     // B=（i节点号-1)/每块含有i节点结构数。例如，节点号16的i节点结构应该在B=（16-1）/16 = 0
  463.     // 的块上。
  464.     block = 2 + sb->s_imap_blocks + sb->s_zmap_blocks +
  465.         (inode->i_num-1)/INODES_PER_BLOCK;
  466.     // 这里我们从设备上读取该i节点所在的逻辑块，并复制指定i节点内容到inode指针所指位置处。
  467.     if (!(bh=bread(inode->i_dev,block)))
  468.         panic("unable to read i-node block");
  469.     *(struct d_inode *)inode =
  470.         ((struct d_inode *)bh->b_data)
  471.             [(inode->i_num-1)%INODES_PER_BLOCK];
  472.     // 最后释放读入的缓冲块，并解锁该i节点。
  473.     brelse(bh);
  474.     unlock_inode(inode);
  475. }
  477. //// 将i节点信息写入缓冲区中。
  478. // 该函数把参数指定的i节点写入缓冲区相应的缓冲块中，待缓冲区刷新时会写入盘中。为了确定i节点
  479. // 所在的设备逻辑块号（或缓冲块），必须首先读取相应设备上的超级块，以获取用于计算逻辑块号的
  480. // 每块i节点数信息INODES_PER_BLOCK。在计算出i节点所在的逻辑块号后，就把该逻辑块读入一缓冲块
  481. // 中。然后把i节点内容复制到缓冲块的相应位置处。
  482. static void write_inode(struct m_inode * inode)
  483. {
  484.     struct super_block * sb;
  485.     struct buffer_head * bh;
  486.     int block;
  488.     // 首先锁定该i节点，如果该i节点没有被修改或者该i节点的设备号等于零，则解锁该i节点，并退出。
  489.     lock_inode(inode);
  490.     if (!inode->i_dirt || !inode->i_dev) {
  491.         unlock_inode(inode);
  492.         // 不需要把i节点信息写入到缓冲区
  493.         return;
  494.     }
  495.     // 取超级块，之后可以根据超级块中的信息得到 要写的i节点
  496.     if (!(sb=get_super(inode->i_dev)))
  497.         panic("trying to write inode without device");
  498.     // 该i节点所在的设备逻辑块号＝（启动块+超级块）+i节点位图占用的块数+逻辑块位图占用的块数
  499.     // +（i节点号-1）/每块含有的i节点数。我们从设备上读取i节点所在的逻辑块，并将该i节点信息复制
  500.     // 到逻辑块对应i节点的项位置处。
  501.     block = 2 + sb->s_imap_blocks + sb->s_zmap_blocks +
  502.         (inode->i_num-1)/INODES_PER_BLOCK;
  503.     if (!(bh=bread(inode->i_dev,block)))
  504.         panic("unable to read i-node block");
  505.     ((struct d_inode *)bh->b_data)
  506.         [(inode->i_num-1)%INODES_PER_BLOCK] =
  507.             *(struct d_inode *)inode;
  508.     // 然后置缓冲区已修改标志，而i节点内容已经与缓冲区中的一致，因此修改标志置零。然后释放该
  509.     // 含有i节点的缓冲区，并解锁该i节点。
  510.     bh->b_dirt=1;
  511.     inode->i_dirt=0;
  512.     brelse(bh); // 现在虽然释放了bh缓冲块，而且没有进行同步，同步操作在getblk()中
  513.     unlock_inode(inode);
  514. }

疑问

问题 解答
invalidate_inodes()函数中是否必须要等待i节点解锁才释放i节点 是，直接释放后果很严重，会使正在使用这个i节点的进程出现问题
invalidate_inodes()函数中是否必须先等待i节点解锁，才查看设备号是否符合,而不是先查设备号，符合的再等待该i节点解锁
存在和 buffer.c 中 wait_on_buffer() 函数相同的问题，具体的解答有待商榷 解释类 bufffer.c中 wait_on_buffer()的解释

- 问题:
关于缓冲块与块设备之间的同步问题，释放缓冲块的函数brelse中没有进行同步，就可能会被其他进程使用?
- 解答：
经过仔细的阅读，发现 只有缓冲块被使用时对缓冲块位置的处理，而没有缓冲块被释放时关于位置的处理。实际上，它采用的方式是使用缓冲块的时候把该缓冲块加入到hash表中，并且加入到空闲队列的尾部。当它不再使用时，别的进程还是通过 getblk()函数来获取缓冲块，这个不再使用的缓冲块就有可能被使用。而在getblk()函数中，在寻找可用的空闲缓冲块的过程中会对 缓冲块进行同步操作。

想法

  1. 在这个源文件中，主要是对i节点的操作，包括获取内存中空闲i节点项、释放i节点(只是一个进程释放)、读取指定i节点号的i节点信息、把i节点信息写入等操作。
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注