����12-4 linux/fs/inode.c


  1 /*

  2  *  linux/fs/inode.c

  3  *

  4  *  (C) 1991  Linus Torvalds

  5  */

  6

  7 #include <string.h>       // �ַ���ͷ�ļ�����Ҫ������һЩ�й��ַ���������Ƕ�뺯����

  8 #include <sys/stat.h>     // �ļ�״̬ͷ�ļ��������ļ����ļ�ϵͳ״̬�ṹstat{}�ͳ�����

  9

 10 #include <linux/sched.h>  // ���ȳ���ͷ�ļ�������������ṹtask_struct������0�����ݣ�

                              // ����һЩ�й��������������úͻ�ȡ��Ƕ��ʽ��ຯ������䡣

 11 #include <linux/kernel.h> // �ں�ͷ�ļ�������һЩ�ں˳��ú�����ԭ�ζ��塣

 12 #include <linux/mm.h>     // �ڴ����ͷ�ļ�������ҳ���С�����һЩҳ���ͷź���ԭ�͡�

 13 #include <asm/system.h>   // ϵͳͷ�ļ������������û��޸�������/�ж��ŵȵ�Ƕ��ʽ���ꡣ

 14

    // �豸���ݿ�����ָ�����顣ÿ��ָ����ָ��ָ�����豸�ŵ��ܿ�������hd_sizes[]������

    // ��������ÿһ���Ӧ���豸��ȷ����һ�����豸����ӵ�е����ݿ�������1���С = 1KB����

 15 extern int *blk_size[];

 16

 17 struct m_inode inode_table[NR_INODE]={{0,},};    // �ڴ���i�ڵ����NR_INODE=32���

 18

 19 static void read_inode(struct m_inode * inode);  // ��ָ��i�ڵ�ŵ�i�ڵ���Ϣ��297�С�

 20 static void write_inode(struct m_inode * inode); // дi�ڵ���Ϣ�����ٻ����У�324�С�

 21

    //// �ȴ�ָ����i�ڵ���á�

    // ���i�ڵ��ѱ��������򽫵�ǰ������Ϊ�����жϵĵȴ�״̬�������ӵ���i�ڵ�ĵȴ���

    // ��i_wait�С�ֱ����i�ڵ��������ȷ�ػ��ѱ�����

 22 static inline void wait_on_inode(struct m_inode * inode)

 23 {

 24         cli();

 25         while (inode->i_lock)

 26                 sleep_on(&inode->i_wait);         // kernel/sched.c����199�С�

 27         sti();

 28 }

 29

    //// ��i�ڵ�����������ָ����i�ڵ㣩��

    // ���i�ڵ��ѱ��������򽫵�ǰ������Ϊ�����жϵĵȴ�״̬�������ӵ���i�ڵ�ĵȴ���

    // ��i_wait�С�ֱ����i�ڵ��������ȷ�ػ��ѱ�����Ȼ�����������

 30 static inline void lock_inode(struct m_inode * inode)

 31 {

 32         cli();

 33         while (inode->i_lock)

 34                 sleep_on(&inode->i_wait);

 35         inode->i_lock=1;                         // ��������־��

 36         sti();

 37 }

 38

    //// ��ָ����i�ڵ������

    // ��λi�ڵ��������־������ȷ�ػ��ѵȴ��ڴ�i�ڵ�ȴ�����i_wait�ϵ����н��̡�

 39 static inline void unlock_inode(struct m_inode * inode)

 40 {

 41         inode->i_lock=0;

 42         wake_up(&inode->i_wait);                // kernel/sched.c����204�С�

 43 }

 44

    //// �ͷ��豸dev���ڴ�i�ڵ���е�����i�ڵ㡣

    // ɨ���ڴ��е�i�ڵ�����飬�����ָ���豸ʹ�õ�i�ڵ���ͷ�֮��

 45 void invalidate_inodes(int dev)

 46 {

 47         int i;

 48         struct m_inode * inode;

 49

    // ������ָ��ָ���ڴ�i�ڵ���������Ȼ��ɨ��i�ڵ��ָ�������е�����i�ڵ㡣���

    // ����ÿ��i�ڵ㣬�ȵȴ���i�ڵ�������ã���Ŀǰ���������Ļ��������ж��Ƿ�����ָ��

    // �豸��i�ڵ㡣�����ָ���豸��i�ڵ㣬�򿴿����Ƿ񻹱�ʹ���ţ��������ü����Ƿ�

    // Ϊ0����������ʾ������Ϣ��Ȼ���ͷ�֮������i�ڵ���豸���ֶ�i_dev��0����50����

    // ��ָ�븳ֵ "0+inode_table " ��ͬ�� "inode_table"��"&inode_table[0] "����������д

    // ���ܸ�����һЩ��

 50         inode = 0+inode_table;                  // ָ��i�ڵ��ָ���������

 51         for(i=0 ; i<NR_INODE ; i++,inode++) {

 52                 wait_on_inode(inode);           // �ȴ���i�ڵ���ã���������

 53                 if (inode->i_dev == dev) {

 54                         if (inode->i_count)     // ������������Ϊ0������ʾ�������档

 55                                 printk("inode in use on removed disk\n\r");

 56                         inode->i_dev = inode->i_dirt = 0; // �ͷ�i�ڵ�(���豸��Ϊ0)��

 57                 }

 58         }

 59 }

 60

    //// ͬ������i�ڵ㡣

    // ���ڴ�i�ڵ��������i�ڵ����豸��i�ڵ���ͬ��������

 61 void sync_inodes(void)

 62 {

 63         int i;

 64         struct m_inode * inode;

 65

    // �������ڴ�i�ڵ����͵�ָ��ָ��i�ڵ�����Ȼ��ɨ������i�ڵ���еĽڵ㡣���

    // ����ÿ��i�ڵ㣬�ȵȴ���i�ڵ�������ã���Ŀǰ���������Ļ�����Ȼ���жϸ�i�ڵ�

    // �Ƿ��ѱ��޸IJ��Ҳ��ǹܵ��ڵ㡣������������򽫸�i�ڵ�д����ٻ������С�������

    // ��������buffer.c�����ʵ�ʱ��������д�����С�

 66         inode = 0+inode_table;                  // ��ָ������ָ��i�ڵ��ָ���������

 67         for(i=0 ; i<NR_INODE ; i++,inode++) {   // ɨ��i�ڵ��ָ�����顣

 68                 wait_on_inode(inode);           // �ȴ���i�ڵ���ã���������

 69                 if (inode->i_dirt && !inode->i_pipe)  // ��i�ڵ����޸��Ҳ��ǹܵ��ڵ㣬

 70                         write_inode(inode);           // ��д�̣�ʵ����д�뻺�����У���

 71         }

 72 }

 73

    //// �ļ����ݿ�ӳ�䵽�̿�Ĵ�����������blockλͼ����������bmap - block map��

    // ������inode �C �ļ���i�ڵ�ָ�룻block �C �ļ��е����ݿ�ţ�create - �������־��

    // �ú�����ָ�����ļ����ݿ�block��Ӧ���豸���߼����ϣ��������߼���š����������־

    // ��λ�������豸�϶�Ӧ�߼��鲻����ʱ�������´��̿飬�����ļ����ݿ�block��Ӧ���豸

    // �ϵ��߼���ţ��̿�ţ���

 74 static int _bmap(struct m_inode * inode,int block,int create)

 75 {

 76         struct buffer_head * bh;

 77         int i;

 78

    // �����жϲ����ļ����ݿ��block����Ч�ԡ�������С��0����ͣ���������Ŵ���ֱ��

    // ���� + ��ӿ��� + ���μ�ӿ����������ļ�ϵͳ��ʾ��Χ����ͣ����

 79         if (block<0)

 80                 panic("_bmap: block<0");

 81         if (block >= 7+512+512*512)

 82                 panic("_bmap: block>big");

    // Ȼ������ļ���ŵĴ�Сֵ���Ƿ������˴�����־�ֱ���д���������ÿ��С��7����ʹ

    // ��ֱ�ӿ��ʾ�����������־��λ������i�ڵ��ж�Ӧ�ÿ���߼��飨���Σ��ֶ�Ϊ0����

    // ����Ӧ�豸����һ���̿飨�߼��飩�����ҽ������߼���ţ��̿�ţ������߼����ֶ��С�

    // Ȼ������i�ڵ�ı�ʱ�䣬��i�ڵ����޸ı�־�� ��󷵻��߼���š� ����new_block()

    // ������bitmap.c�����е�76�п�ʼ����

 83         if (block<7) {

 84                 if (create && !inode->i_zone[block])

 85                         if (inode->i_zone[block]=new_block(inode->i_dev)) {

 86                                 inode->i_ctime=CURRENT_TIME; // ctime - Change time��

 87                                 inode->i_dirt=1;             // �������޸ı�־��

 88                         }

 89                 return inode->i_zone[block];

 90         }

    // ����ÿ��>=7����С��7+512����˵��ʹ�õ���һ�μ�ӿ顣�����һ�μ�ӿ���д�����

    // ����Ǵ��������Ҹ�i�ڵ��ж�Ӧ��ӿ��ֶ�i_zone[7]��0�������ļ����״�ʹ�ü�ӿ飬

    // ��������һ���̿����ڴ�ż�ӿ���Ϣ��������ʵ�ʴ��̿�������ӿ��ֶ��С� Ȼ����

    // ��i�ڵ����޸ı�־���޸�ʱ�䡣 �������ʱ������̿�ʧ�ܣ����ʱi�ڵ��ӿ��ֶ�

    // i_zone[7]Ϊ0���򷵻�0�����߲��Ǵ�������i_zone[7]ԭ����Ϊ0������i�ڵ���û�м�

    // �ӿ飬����ӳ����̿�ʧ�ܣ�����0�˳���

 91         block -= 7;

 92         if (block<512) {

 93                 if (create && !inode->i_zone[7])

 94                         if (inode->i_zone[7]=new_block(inode->i_dev)) {

 95                                 inode->i_dirt=1;

 96                                 inode->i_ctime=CURRENT_TIME;

 97                         }

 98                 if (!inode->i_zone[7])

 99                         return 0;

    // ���ڶ�ȡ�豸�ϸ�i�ڵ��һ�μ�ӿ顣��ȡ�ü�ӿ��ϵ�block���е��߼���ţ��̿�

    // �ţ�i��ÿһ��ռ2���ֽڡ�����Ǵ������Ҽ�ӿ�ĵ�block���е��߼����Ϊ0�Ļ���

    // ������һ���̿飬���ü�ӿ��еĵ�block����ڸ����߼����š�Ȼ����λ��ӿ����

    // �޸ı�־��������Ǵ�������i������Ҫӳ�䣨Ѱ�ң����߼���š�

100                 if (!(bh = bread(inode->i_dev,inode->i_zone[7])))

101                         return 0;

102                 i = ((unsigned short *) (bh->b_data))[block];

103                 if (create && !i)

104                         if (i=new_block(inode->i_dev)) {

105                                 ((unsigned short *) (bh->b_data))[block]=i;

106                                 bh->b_dirt=1;

107                         }

    // ����ͷŸü�ӿ�ռ�õĻ���飬�����ش������������ԭ�еĶ�Ӧblock���߼����š�

108                 brelse(bh);

109                 return i;

110         }

    // ���������е��ˣ���������ݿ����ڶ��μ�ӿ顣�䴦��������һ�μ�ӿ����ơ������Ƕ�

    // ���μ�ӿ�Ĵ��������Ƚ�block�ټ�ȥ��ӿ������ɵĿ�����512����Ȼ������Ƿ�����

    // �˴�����־���д�����Ѱ�Ҵ�����������´�������i�ڵ�Ķ��μ�ӿ��ֶ�Ϊ0��������

    // ��һ���̿����ڴ�Ŷ��μ�ӿ��һ������Ϣ��������ʵ�ʴ��̿��������μ�ӿ��ֶ�

    // �С�֮����i�ڵ����޸ı��ƺ��޸�ʱ�䡣ͬ���أ��������ʱ������̿�ʧ�ܣ����

    // ʱi�ڵ���μ�ӿ��ֶ�i_zone[8]Ϊ0���򷵻�0�����߲��Ǵ�������i_zone[8]ԭ����

    // Ϊ0������i�ڵ���û�м�ӿ飬����ӳ����̿�ʧ�ܣ�����0�˳���

111         block -= 512;

112         if (create && !inode->i_zone[8])

113                 if (inode->i_zone[8]=new_block(inode->i_dev)) {

114                         inode->i_dirt=1;

115                         inode->i_ctime=CURRENT_TIME;

116                 }

117         if (!inode->i_zone[8])

118                 return 0;

    // ���ڶ�ȡ�豸�ϸ�i�ڵ�Ķ��μ�ӿ顣��ȡ�ö��μ�ӿ��һ�����ϵ� (block/512)

    // ���е��߼����i������Ǵ������Ҷ��μ�ӿ��һ�����ϵ� (block/512) ���е��߼�

    // ���Ϊ0�Ļ�����������һ���̿飨�߼��飩��Ϊ���μ�ӿ�Ķ�����i�����ö��μ��

    // ���һ�����е� (block/512)����ڸö�����Ŀ��i��Ȼ����λ���μ�ӿ��һ������

    // �޸ı�־�����ͷŶ��μ�ӿ��һ���顣������Ǵ�������i������Ҫӳ�䣨Ѱ�ң�����

    // ����š�

119         if (!(bh=bread(inode->i_dev,inode->i_zone[8])))

120                 return 0;

121         i = ((unsigned short *)bh->b_data)[block>>9];

122         if (create && !i)

123                 if (i=new_block(inode->i_dev)) {

124                         ((unsigned short *) (bh->b_data))[block>>9]=i;

125                         bh->b_dirt=1;

126                 }

127         brelse(bh);

    // ������μ�ӿ�Ķ�������Ϊ0����ʾ������̿�ʧ�ܻ���ԭ����Ӧ��ž�Ϊ0����

    // ��0�˳�������ʹ��豸�϶�ȡ���μ�ӿ�Ķ����飬��ȡ�ö������ϵ�block���е���

    // ����ţ�����511��Ϊ���޶�blockֵ������511����

128         if (!i)

129                 return 0;

130         if (!(bh=bread(inode->i_dev,i)))

131                 return 0;

132         i = ((unsigned short *)bh->b_data)[block&511];

    // ����Ǵ������Ҷ�����ĵ�block�����߼����Ϊ0�Ļ���������һ���̿飨�߼��飩��

    // ��Ϊ���մ��������Ϣ�Ŀ顣���ö������еĵ�block����ڸ����߼�����(i)��Ȼ��

    // ��λ����������޸ı�־��

133         if (create && !i)

134                 if (i=new_block(inode->i_dev)) {

135                         ((unsigned short *) (bh->b_data))[block&511]=i;

136                         bh->b_dirt=1;

137                 }

    // ����ͷŸö��μ�ӿ�Ķ����飬���ش�����������Ļ�ԭ�еĶ�Ӧblock���߼����š�

138         brelse(bh);

139         return i;

140 }

141

    //// ȡ�ļ����ݿ�block���豸�϶�Ӧ���߼���š�

    // ������inode �C �ļ����ڴ�i�ڵ�ָ�룻block �C �ļ��е����ݿ�š�

    // �������ɹ��򷵻ض�Ӧ���߼���ţ����򷵻�0��

142 int bmap(struct m_inode * inode,int block)

143 {

144         return _bmap(inode,block,0);

145 }

146

    //// ȡ�ļ����ݿ�block���豸�϶�Ӧ���߼���š������Ӧ���߼��鲻���ھʹ���һ�顣

    // �������豸�϶�Ӧ���߼���š�

    // ������inode �C �ļ����ڴ�i�ڵ�ָ�룻block �C �ļ��е����ݿ�š�

    // �������ɹ��򷵻ض�Ӧ���߼���ţ����򷵻�0��

147 int create_block(struct m_inode * inode, int block)

148 {

149         return _bmap(inode,block,1);

150 }

151                

    //// �Żأ����ã�һ��i�ڵ�(��д���豸)��

    // �ú�����Ҫ���ڰ�i�ڵ����ü���ֵ�ݼ�1���������ǹܵ�i�ڵ㣬���ѵȴ��Ľ��̡�

    // ���ǿ��豸�ļ�i�ڵ���ˢ���豸��������i�ڵ�����Ӽ���Ϊ0�����ͷŸ�i�ڵ�ռ��

    // �����д����߼��飬���ͷŸ�i�ڵ㡣

152 void iput(struct m_inode * inode)

153 {

    // �����жϲ���������i�ڵ����Ч�ԣ����ȴ�inode�ڵ����������������Ļ��������i

    // �ڵ�����ü���Ϊ0����ʾ��i�ڵ��Ѿ��ǿ��еġ��ں���Ҫ�������зŻز�����˵����

    // �����������������⡣������ʾ������Ϣ��ͣ����

154         if (!inode)

155                 return;

156         wait_on_inode(inode);

157         if (!inode->i_count)

158                 panic("iput: trying to free free inode");

    // ����ǹܵ�i�ڵ㣬���ѵȴ��ùܵ��Ľ��̣����ô�����1��������������򷵻ء�����

    // �ͷŹܵ�ռ�õ��ڴ�ҳ�棬����λ�ýڵ�����ü���ֵ�����޸ı�־�͹ܵ���־�������ء�

    // ���ڹܵ��ڵ㣬inode->i_size������ڴ�ҳ��ַ���μ�get_pipe_inode()��231��237�С�

159         if (inode->i_pipe) {

160                 wake_up(&inode->i_wait);

161                 wake_up(&inode->i_wait2);          //

162                 if (--inode->i_count)

163                         return;

164                 free_page(inode->i_size);

165                 inode->i_count=0;

166                 inode->i_dirt=0;

167                 inode->i_pipe=0;

168                 return;

169         }

    // ���i�ڵ��Ӧ���豸�� = 0���򽫴˽ڵ�����ü����ݼ�1�����ء��������ڹܵ�������

    // i�ڵ㣬��i�ڵ���豸��Ϊ0��

170         if (!inode->i_dev) {

171                 inode->i_count--;

172                 return;

173         }

    // ����ǿ��豸�ļ���i�ڵ㣬��ʱ�߼����ֶ�0��i_zone[0]�������豸�ţ���ˢ�¸��豸��

    // ���ȴ�i�ڵ������

174         if (S_ISBLK(inode->i_mode)) {

175                 sync_dev(inode->i_zone[0]);

176                 wait_on_inode(inode);

177         }

    // ���i�ڵ�����ü�������1��������ݼ�1���ֱ�ӷ��أ���Ϊ��i�ڵ㻹�������ã�����

    // �ͷţ��������˵��i�ڵ�����ü���ֵΪ1����Ϊ��157���Ѿ��жϹ����ü����Ƿ�Ϊ�㣩��

    // ���i�ڵ��������Ϊ0����˵��i�ڵ��Ӧ�ļ���ɾ���������ͷŸ�i�ڵ�������߼��飬

    // ���ͷŸ�i�ڵ㡣����free_inode()����ʵ���ͷ�i�ڵ����������λi�ڵ��Ӧ��i�ڵ�λ

    // ͼ����λ�����i�ڵ�ṹ���ݡ�

178 repeat:

179         if (inode->i_count>1) {

180                 inode->i_count--;

181                 return;

182         }

183         if (!inode->i_nlinks) {

184                 truncate(inode);

185                 free_inode(inode);         // bitmap.c ��108�п�ʼ����

186                 return;

187         }

    // �����i�ڵ��������޸ģ����д���¸�i�ڵ㣬���ȴ���i�ڵ����������������дi��

    // ��ʱ��Ҫ�ȴ�˯�ߣ���ʱ���������п����޸ĸ�i�ڵ㣬����ڽ��̱����Ѻ���Ҫ�ٴ��ظ�

    // ���������жϹ��̣�repeat����

188         if (inode->i_dirt) {

189                 write_inode(inode);        /* we can sleep - so do again */

190                 wait_on_inode(inode);      /* ��Ϊ����˯���ˣ�������Ҫ�ظ��ж� */

191                 goto repeat;

192         }

    // ��������ִ�е��ˣ���˵����i�ڵ�����ü���ֵi_count��1����������Ϊ�㣬��������

    // û�б��޸Ĺ�����˴�ʱֻҪ��i�ڵ����ü����ݼ�1�����ء���ʱ��i�ڵ��i_count=0��

    // ��ʾ���ͷš�

193         inode->i_count--;

194         return;

195 }

196

    //// ��i�ڵ����inode_table���л�ȡһ������i�ڵ��

    // Ѱ�����ü���countΪ0��i�ڵ㣬������д�̺����㣬������ָ�롣���ü�������1��

197 struct m_inode * get_empty_inode(void)

198 {

199         struct m_inode * inode;

200         static struct m_inode * last_inode = inode_table;   // ָ��i�ڵ����1�

201         int i;

202

    // �ڳ�ʼ��last_inodeָ��ָ��i�ڵ��ͷһ���ѭ��ɨ������i�ڵ�������last_inode

    // �Ѿ�ָ��i�ڵ�������1��֮������������ָ��i�ڵ����ʼ�����Լ���ѭ��Ѱ�ҿ���

    // i�ڵ����� last_inode��ָ���i�ڵ�ļ���ֵΪ0����˵�������ҵ�����i�ڵ��

    // ��inodeָ���i�ڵ㡣�����i�ڵ�����޸ı�־��������־��Ϊ0�������ǿ���ʹ�ø�

    // i�ڵ㣬�����˳�forѭ����

203         do {

204                 inode = NULL;

205                 for (i = NR_INODE; i ; i--) {                // NR_INODE = 32��

206                         if (++last_inode >= inode_table + NR_INODE)

207                                 last_inode = inode_table;

208                         if (!last_inode->i_count) {

209                                 inode = last_inode;

210                                 if (!inode->i_dirt && !inode->i_lock)

211                                         break;

212                         }

213                 }

    // ���û���ҵ�����i�ڵ㣨inode = NULL������i�ڵ����ӡ����������ʹ�ã���ͣ����

214                 if (!inode) {

215                         for (i=0 ; i<NR_INODE ; i++)

216                                 printk("%04x: %6d\t",inode_table[i].i_dev,

217                                         inode_table[i].i_num);

218                         panic("No free inodes in mem");

219                 }

    // �ȴ���i�ڵ����������ֱ������Ļ����������i�ڵ����޸ı�־����λ�Ļ����򽫸�

    // i�ڵ�ˢ�£�ͬ��������Ϊˢ��ʱ���ܻ�˯�ߣ������Ҫ�ٴ�ѭ���ȴ���i�ڵ������

220                 wait_on_inode(inode);

221                 while (inode->i_dirt) {

222                         write_inode(inode);

223                         wait_on_inode(inode);

224                 }

225         } while (inode->i_count);

    // ���i�ڵ��ֱ�����ռ�õĻ���i�ڵ�ļ���ֵ��Ϊ0�ˣ���������Ѱ�ҿ���i�ڵ㡣����

    // ˵�����ҵ�����Ҫ��Ŀ���i�ڵ���򽫸�i�ڵ����������㣬�������ü���Ϊ1������

    // ��i�ڵ�ָ�롣

226         memset(inode,0,sizeof(*inode));

227         inode->i_count = 1;

228         return inode;

229 }

230

    //// ��ȡ�ܵ��ڵ㡣

    // ����ɨ��i�ڵ����Ѱ��һ������i�ڵ��Ȼ��ȡ��һҳ�����ڴ湩�ܵ�ʹ�á�Ȼ�󽫵�

    // ����i�ڵ�����ü�����Ϊ2(���ߺ�д��)����ʼ���ܵ�ͷ��β����i�ڵ�Ĺܵ����ͱ�ʾ��

    // ����Ϊi�ڵ�ָ�룬���ʧ���򷵻�NULL��

231 struct m_inode * get_pipe_inode(void)

232 {

233         struct m_inode * inode;

234

    // ���ȴ��ڴ�i�ڵ����ȡ��һ������i�ڵ㡣����Ҳ�������i�ڵ��򷵻�NULL��Ȼ��Ϊ��

    // i�ڵ�����һҳ�ڴ棬���ýڵ��i_size�ֶ�ָ���ҳ�档�����û�п����ڴ棬���ͷŸ�

    // i�ڵ㣬������NULL��

235         if (!(inode = get_empty_inode()))

236                 return NULL;

237         if (!(inode->i_size=get_free_page())) {     // �ڵ��i_size�ֶ�ָ�򻺳�����

238                 inode->i_count = 0;

239                 return NULL;

240         }

    // Ȼ�����ø�i�ڵ�����ü���Ϊ2������λ��λ�ܵ�ͷβָ�롣i�ڵ��߼��������i_zone[]

    // ��i_zone[0]��i_zone[1]�зֱ�������Źܵ�ͷ�͹ܵ�βָ�롣�������i�ڵ��ǹܵ�i��

    // ���־�����ظ�i�ڵ�š�

241         inode->i_count = 2;     /* sum of readers/writers */   /* ��/д�����ܼ� */

242         PIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;  // ��λ�ܵ�ͷβָ�롣

243         inode->i_pipe = 1;                          // �ýڵ�Ϊ�ܵ�ʹ�õı�־��

244         return inode;

245 }

246

    //// ȡ��һ��i�ڵ㡣

    // ������dev - �豸�ţ�nr - i�ڵ�š�

    // ���豸�϶�ȡָ���ڵ�ŵ�i�ڵ�ṹ���ݵ��ڴ�i�ڵ���У����ҷ��ظ�i�ڵ�ָ�롣

    // ������λ�ڸ��ٻ������е�i�ڵ������Ѱ�����ҵ�ָ���ڵ�ŵ�i�ڵ����ھ���һЩ�ж�

    // �����󷵻ظ�i�ڵ�ָ�롣������豸dev�϶�ȡָ��i�ڵ�ŵ�i�ڵ���Ϣ����i�ڵ��

    // �У������ظ�i�ڵ�ָ�롣

247 struct m_inode * iget(int dev,int nr)

248 {

249         struct m_inode * inode, * empty;

250

    // �����жϲ�����Ч�ԡ����豸����0��������ں˴������⣬��ʾ������Ϣ��ͣ����Ȼ��Ԥ

    // �ȴ�i�ڵ����ȡһ������i�ڵ㱸�á�

251         if (!dev)

252                 panic("iget with dev==0");

253         empty = get_empty_inode();

    // ����ɨ��i�ڵ����Ѱ�Ҳ���ָ���ڵ��nr��i�ڵ㡣�������ýڵ�����ô����������

    // ǰɨ��i�ڵ���豸�Ų�����ָ�����豸�Ż��߽ڵ�Ų�����ָ���Ľڵ�ţ������ɨ�衣

254         inode = inode_table;

255         while (inode < NR_INODE+inode_table) {

256                 if (inode->i_dev != dev || inode->i_num != nr) {

257                         inode++;

258                         continue;

259                 }

    // ����ҵ�ָ���豸��dev �ͽڵ�� nr ��i�ڵ㣬��ȴ��ýڵ����������������Ļ�����

    // �ڵȴ��ýڵ���������У�i�ڵ�����ܻᷢ���仯�������ٴν���������ͬ�жϡ������

    // ���˱仯�����ٴ�����ɨ������i�ڵ����

260                 wait_on_inode(inode);

261                 if (inode->i_dev != dev || inode->i_num != nr) {

262                         inode = inode_table;

263                         continue;

264                 }

    // �������ʾ�ҵ���Ӧ��i�ڵ㡣���ǽ���i�ڵ����ü�����1��Ȼ��������һ����飬����

    // �Ƿ�����һ���ļ�ϵͳ�İ�װ�㡣������Ѱ�ұ���װ�ļ�ϵͳ���ڵ㲢���ء������i�ڵ�

    // ��ȷ�������ļ�ϵͳ�İ�װ�㣬���ڳ����������Ѱ��װ�ڴ�i�ڵ�ij����顣���û����

    // ��������ʾ������Ϣ�����Żر�������ʼʱ��ȡ�Ŀ��нڵ�empty�����ظ�i�ڵ�ָ�롣

265                 inode->i_count++;

266                 if (inode->i_mount) {

267                         int i;

268

269                         for (i = 0 ; i<NR_SUPER ; i++)

270                                 if (super_block[i].s_imount==inode)

271                                         break;

272                         if (i >= NR_SUPER) {

273                                 printk("Mounted inode hasn't got sb\n");

274                                 if (empty)

275                                         iput(empty);

276                                 return inode;

277                         }

    // ִ�е������ʾ�Ѿ��ҵ���װ��inode�ڵ���ļ�ϵͳ�����顣���ǽ���i�ڵ�д�̷Żأ�

    // ���Ӱ�װ�ڴ�i�ڵ��ϵ��ļ�ϵͳ��������ȡ�豸�ţ�����i�ڵ��ΪROOT_INO����Ϊ1��

    // Ȼ������ɨ������i�ڵ�����Ի�ȡ�ñ���װ�ļ�ϵͳ�ĸ�i�ڵ���Ϣ��

278                         iput(inode);

279                         dev = super_block[i].s_dev;

280                         nr = ROOT_INO;

281                         inode = inode_table;

282                         continue;

283                 }

    // ���������ҵ�����Ӧ��i�ڵ㡣��˿��Է�����������ʼ����ʱ����Ŀ���i�ڵ㣬����

    // �ҵ���i�ڵ�ָ�롣

284                 if (empty)

285                         iput(empty);

286                 return inode;

287         }

    // ���������i�ڵ����û���ҵ�ָ����i�ڵ㣬������ǰ������Ŀ���i�ڵ�empty��i

    // �ڵ���н�����i�ڵ㡣������Ӧ�豸�϶�ȡ��i�ڵ���Ϣ�����ظ�i�ڵ�ָ�롣

288         if (!empty)

289                 return (NULL);

290         inode=empty;

291         inode->i_dev = dev;                  // ����i�ڵ���豸��

292         inode->i_num = nr;                   // ����i�ڵ�š�

293         read_inode(inode);

294         return inode;

295 }

296

    //// ��ȡָ��i�ڵ���Ϣ��

    // ���豸�϶�ȡ����ָ��i�ڵ���Ϣ��i�ڵ��̿飬Ȼ���Ƶ�ָ����i�ڵ�ṹ�С� Ϊ��

    // ȷ��i�ڵ����ڵ��豸�߼���ţ��򻺳�飩���������ȶ�ȡ��Ӧ�豸�ϵij����飬�Ի�ȡ

    // ���ڼ����߼���ŵ�ÿ��i�ڵ�����Ϣ INODES_PER_BLOCK�� �ڼ����i�ڵ����ڵ��߼���

    // �ź󣬾ͰѸ��߼������һ������С�Ȼ��ѻ��������Ӧλ�ô���i�ڵ����ݸ��Ƶ�����

    // ָ����λ�ô���

297 static void read_inode(struct m_inode * inode)

298 {

299         struct super_block * sb;

300         struct buffer_head * bh;

301         int block;

302

    // ����������i�ڵ㣬��ȡ�ýڵ������豸�ij����顣

303         lock_inode(inode);

304         if (!(sb=get_super(inode->i_dev)))

305                 panic("trying to read inode without dev");

    // ��i�ڵ����ڵ��豸�߼���� = (������ + ������) + i�ڵ�λͼռ�õĿ��� + �߼���λ

    // ͼռ�õĿ��� + (i�ڵ��-1)/ÿ�麬�е�i�ڵ�������Ȼi�ڵ�Ŵ�0��ʼ��ţ�����1

    // ��0��i�ڵ㲻�ã����Ҵ�����Ҳ�������Ӧ��0��i�ڵ�ṹ����˴��i�ڵ���̿��

    // ��1���ϱ������i�ڵ������1--16��i�ڵ�ṹ������0--15�ġ�������������i��

    // ��Ŷ�Ӧ��i�ڵ�ṹ�����̿�ʱ��Ҫ��1������B =(i�ڵ��-1)/ÿ�麬��i�ڵ�ṹ����

    // ���磬�ڵ��16��i�ڵ�ṹӦ����B=(16-1)/16 = 0�Ŀ��ϡ� �������Ǵ��豸�϶�ȡ��

    // i�ڵ����ڵ��߼��飬������ָ��i�ڵ����ݵ�inodeָ����ָλ�ô���

306         block = 2 + sb->s_imap_blocks + sb->s_zmap_blocks +

307                 (inode->i_num-1)/INODES_PER_BLOCK;

308         if (!(bh=bread(inode->i_dev,block)))

309                 panic("unable to read i-node block");

310         *(struct d_inode *)inode =

311                 ((struct d_inode *)bh->b_data)

312                         [(inode->i_num-1)%INODES_PER_BLOCK];

    // ����ͷŶ���Ļ���飬��������i�ڵ㡣���ڿ��豸�ļ�������Ҫ����i�ڵ���ļ����

    // ����ֵ��

313         brelse(bh);

314         if (S_ISBLK(inode->i_mode)) {

315                 int i = inode->i_zone[0];   // ���ڿ��豸�ļ���i_zone[0]�����豸�š�

316                 if (blk_size[MAJOR(i)])

317                         inode->i_size = 1024*blk_size[MAJOR(i)][MINOR(i)];

318                 else

319                         inode->i_size = 0x7fffffff;

320         }

321         unlock_inode(inode);

322 }

323

    //// ��i�ڵ���Ϣд�뻺�����С�

    // �ú����Ѳ���ָ����i�ڵ�д�뻺������Ӧ�Ļ�����У���������ˢ��ʱ��д�����С�Ϊ��

    // ȷ��i�ڵ����ڵ��豸�߼���ţ��򻺳�飩���������ȶ�ȡ��Ӧ�豸�ϵij����飬�Ի�ȡ

    // ���ڼ����߼���ŵ�ÿ��i�ڵ�����Ϣ INODES_PER_BLOCK�� �ڼ����i�ڵ����ڵ��߼���

    // �ź󣬾ͰѸ��߼������һ������С�Ȼ���i�ڵ����ݸ��Ƶ���������Ӧλ�ô���

324 static void write_inode(struct m_inode * inode)

325 {

326         struct super_block * sb;

327         struct buffer_head * bh;

328         int block;

329

    // ����������i�ڵ㣬�����i�ڵ�û�б��޸Ĺ����߸�i�ڵ���豸�ŵ����㣬�������

    // i�ڵ㣬���˳�������û�б��޸Ĺ���i�ڵ㣬�������뻺�����л��豸�е���ͬ�� Ȼ��

    // ��ȡ��i�ڵ�ij����顣

330         lock_inode(inode);

331         if (!inode->i_dirt || !inode->i_dev) {

332                 unlock_inode(inode);

333                 return;

334         }

335         if (!(sb=get_super(inode->i_dev)))

336                 panic("trying to write inode without device");

    // ��i�ڵ����ڵ��豸�߼���� = (������ + ������) + i�ڵ�λͼռ�õĿ��� + �߼���λ

    // ͼռ�õĿ��� + (i�ڵ��-1)/ÿ�麬�е�i�ڵ�����  ���Ǵ��豸�϶�ȡ��i�ڵ����ڵ�

    // �߼��飬������i�ڵ���Ϣ���Ƶ��߼����Ӧ��i�ڵ����λ�ô���

337         block = 2 + sb->s_imap_blocks + sb->s_zmap_blocks +

338                 (inode->i_num-1)/INODES_PER_BLOCK;

339         if (!(bh=bread(inode->i_dev,block)))

340                 panic("unable to read i-node block");

341         ((struct d_inode *)bh->b_data)

342                 [(inode->i_num-1)%INODES_PER_BLOCK] =

343                         *(struct d_inode *)inode;

    // Ȼ���û��������޸ı�־����i�ڵ������Ѿ��뻺�����е�һ�£�����޸ı�־���㡣Ȼ��

    // �ͷŸú���i�ڵ�Ļ���������������i�ڵ㡣

344         bh->b_dirt=1;

345         inode->i_dirt=0;

346         brelse(bh);

347         unlock_inode(inode);

348 }

349