看到论坛前辈们用一帖就勾引出来那么多牛人，我也想试试

bwater

支持继续讨论下去，难道cu只有secworld和塑料袋真正懂内核吗，那也太............

塑料袋

原帖由 bwater 于 2006-12-19 23:10 发表
支持继续讨论下去，难道cu只有secworld和塑料袋真正懂内核吗，那也太............

我没有当初的好心情了。

在CU这里，谁学习Kernel更深入，谁比较浅薄，以CU的群众基础，是分辨不出来的。
个人学习Kernel，只能是如人饮水，冷暖自知。

俺也想过总结前一段的看的知识，写帖子出来分享，我想还是不会比那本《Linux虚拟内存管理》差太多的，不过想必不要说看懂，有耐心看的人估计也没几个，何必做这损己不利人的事呢，不如再认真一点写，弄本书出，摸俩钱花。

bwater

原帖由 塑料袋 于 2006-12-20 08:32 发表


我没有当初的好心情了。

在CU这里，谁学习Kernel更深入，谁比较浅薄，以CU的群众基础，是分辨不出来的。
个人学习Kernel，只能是如人饮水，冷暖自知。

俺也想过总结前一段的看的知识，写帖子出来分享， ...

其实我不是想看热闹，而是要挖掘下cu的哪个大牛值得我去崇拜

windy_focus

我质疑楼主真的是牛
看你怎么回复我，我就能判断你是不是属牛
1 工作几年了
2 现在什么工作
3 做过哪些性质的工作

东方和尚

很少来这个版块，一来就看到这么多的牛人。狂汗！

secworld

原帖由 塑料袋 于 2006-12-20 08:32 发表


我没有当初的好心情了。

在CU这里，谁学习Kernel更深入，谁比较浅薄，以CU的群众基础，是分辨不出来的。
个人学习Kernel，只能是如人饮水，冷暖自知。

俺也想过总结前一段的看的知识，写帖子出来分享， ...

没必要一下子就变的这么内敛吧?本人还是喜欢你无知的狂性.
你不是要看看一贴可以勾出多少牛人吗?
你不是立志要成为大陆第一的Linux专家高手吗?
你不是要干掉所有CU人吗?
你不是三天就可以精通汇编,七天就了解CPU结构吗?
你不是自称自己是参透九阳真经的杨过吗?
你不是经常去凤楼修行吗?
你不是前一阵子刚得了性病吗?
怎么现在又要....
出书骗人了?

开始看本贴感觉你的功力真的很深,太TM强了,当然和我比还是有一定差距的.但最后你太得意了以至于贴出了自己分析的代码.看了你的注释我哭了,塑料袋竟然不知道那个"--"操作是干什么的,不知道count和del_list之间的关系,不知道什么是互斥保护,同志们当你们看到285楼的时候才知道LZ原来是个大骗子,才知道他根本就不懂什么是过程,什么是kernel.什么是spinlock,什么是count,原来他什么都不懂......自以为看过源代码就号称天下第一了.竟然用成色来品称自己?这种人嘴里的"内核"就会像"小姐","同志","黑客",让人听着变味,听着不舒服.你说我能不伤心吗?事后一想,高手们一般都只在首页部分看看有什么热门话题,如果没有,人就闪了.人家LZ把贴放到CU的IT职业生涯本来就是想保密的,因为本版没有首页推荐功能,所以只能仅供LZ自娱自乐.

楼主说他的问题,CUer们可能十年都解决不了,但我想以他现在的功力出书,就像是在大街上大小便一样,让人做呕.

如果你认为iput的重入会让进程挂掉,就试着写一个exp吧.这样你的研究成果会出现在cve的网站的.也可以让全世界的人都知道CU也有一个0day.最厉害的是发现的vul可以影响所有的linux内核,比h00lyshit强多了,它的只能攻击2.6.17-5以下内核,知道你不喜欢鸟语(我也不喜欢),但我已经很努力了,一些外来词我真不知道怎么翻译给你听.

如果楼主不愿意接招,我也就不费心等待了.但最后劝你几句
1)拳怕少壮,这句话不适合你了.你已经27岁了,但连tcp/ip,proc,chardev,你还都不了解,可以说你在内核上不会有什么大的成就了.不如在家多陪陪老婆,别把时间放到无聊的读核上去.
2)听说你是apache+php,但不知道你可不可以做出一个像sysadmin的web系统来控制Linux kernel.

[ 本帖最后由 secworld 于 2006-12-20 22:37 编辑 ]

塑料袋

原帖由 secworld 于 2006-12-20 22:32 发表


没必要一下子就变的这么内敛吧?本人还是喜欢你无知的狂性.
你不是要看看一贴可以勾出多少牛人吗?
你不是立志要成为大陆第一的Linux专家高手吗?
你不是要干掉所有CU人吗?
你不是三天就可以精通汇编,七天就 ...

不是我变的内敛，是这两天暂时没心思说废话。

我跟你论究Kernel里的程序，是一件费尽吐沫的事。我宁可让所有CUer瞧不起我，也不想把时间浪费在对一个不摸kernel门的人，讲解kernel里边的程序上。

Alyd

上CU 不久,就这样的热闹,看来人气旺啊,
不过LZ 你勾引牛人的目的达到了,可不要撒腿哦

secworld

原帖由 塑料袋 于 2006-12-21 09:16 发表


不是我变的内敛，是这两天暂时没心思说废话。

我跟你论究Kernel里的程序，是一件费尽吐沫的事。我宁可让所有CUer瞧不起我，也不想把时间浪费在对一个不摸kernel门的人，讲解kernel里边的程序上。

如果你不贴你的注释，我可能会认为你真的很牛，但很遗憾，看了注释后可以明确的告诉你，你现在的功力是读核食物链的最底层，连小虾米都不是，顶多是个单细胞的浮游生物吧。我把你在285楼的问题引用过来吧，省的菜鸟和老牛都浪费时间去翻你以前的贴子。我知道你这两天心情不好，因为从我发贴到现在正好是48小时，你却依旧不能参透其中奥秘。失眠了吧？绝望了吧？
我知道这段代码已经远远超过了你的智力极限，你是一个只见语句不见语意的蠢材。你的什么《半年来我的读核体会》简直叫人笑掉大牙，你刚知道用面向对象的方式来读核？七年前这就是共识了，你却以为你找到了什么香饽饽。
等你看懂了才在CU发狂吧，从现在计时，大家都来看看塑料袋到底需要多长时间才能参透其中内核中very常见的保护机制。

1. 
   
2. 我看的是2.4.32的内容,iput()函数相关的部分我不理解,谁如果能解答我的疑惑,感激不尽,谢谢.主要是第二个问题想不明白
   
3. 
   
4. 
   
5. 
   
6. 
   
7. 
   
8. 
   
9. 问题一
   
10. i_count==0时,如果inode->i_nlink>0,且inode存在于hash表中时, 有这样三行代码
    
11.    spin_lock(&inode_lock);
    
12.      inodes_stat.nr_unused--;
    
13.      list_del_init(&inode->i_hash);
    
14. 
    
15. 它为什么能这么肯定的把inode从hash中删除?并且inodes_stat.nr_unused--;
    
16. 从判断出i_count==0,到这三行代码,以前有一段时间,并没有持有自旋锁,执行到这三行时,也许已经inode->i_count>0
    
17. 
    
18. 
    
19. 
    
20. 问题二
    
21. 
    
22. static inline void sync_one(struct inode *inode, int sync)
    
23. {
    
24. 
    
25.    while (inode->i_state & I_LOCK) {
    
26.          __iget(inode);
    
27.          spin_unlock(&inode_lock);
    
28.          __wait_on_inode(inode);
    
29.          iput(inode);
    
30.          spin_lock(&inode_lock);
    
31.    }
    
32.     __sync_one(inode, sync);
    
33. }
    
34. 
    
35. iput在i_count==0时会通过write_inode_now调用这个函数,但是在调用这个函数时,并不一定i_count>0,也许i_count=0. 因为调用write_inode_now之前,已经释放了自旋锁,使其他CPU通过hash得到本inode成为可能
    
36. i_count=0时,SMP上另一进程在kupdate的话,会设置这个i_state为I_LOCK,所以本函数再次iget,然后又iput,
    
37. 在这之间__wait_on_inode的时候,也许另一进程iget到这个inode,对其操作,然后把它标记为I_DIRTY
    
38. ,在i_count==2时调用iput,结束对这个inode的使用,这时i_count==1
    
39. 终于轮到__wait_on_inode(inode)被唤醒再次运行,这个函数在i_count==1时马上又iput,在write_inode_now时,并不持有自旋锁,并不排除SMP上运行kupdate进程的可能,因此这个inode又是I_LOCK,而i_count==0,所以又需要再次iget,iput,这样下去,进程不挂掉??????
    
40. 
    
41. 
    
42. 
    
43. 
    
44. 
    
45. 
    
46. 关联到的代码附加如下
    
47. 
    
48. 
    
49. iput()
    
50.    ...释放预分配块
    
51. 
    
52.   /* i_count--，得到inode_lock自旋锁
    
53.    * 如i_count>0，释放自旋锁，返回0，iput结束
    
54.    * 如i_count=0，继续持有自旋锁，返回1
    
55.      */
    
56.      if (!atomic_dec_and_lock(&inode->i_count, &inode_lock))
    
57.            return;
    
58. 
    
59.      if (!inode->i_nlink) {
    
60. 
    
61.            inode彻底失效，咱不说这种情况
    
62. 
    
63.     }else{ /* 我想了很久这种情况,这里只是暂时持有自旋锁,保证了在这个点上暂时i_count==0*/
    
64. 
    
65.             if (!list_empty(&inode->i_hash)) {
    
66. 
    
67.                    if (!(inode->i_state & (I_DIRTY|I_LOCK)))
    
68.                            __refile_inode(inode);
    
69.                    inodes_stat.nr_unused++;
    
70.                    spin_unlock(&inode_lock);
    
71.                    if (!sb || (sb->s_flags & MS_ACTIVE))
    
72.                           return;
    
73. 
    
74. 
    
75.                    /* 执行到这里时，由于前几行代码已经释放了自旋锁,所以也许SMP已经使这个
    
76.              *inode->i_count>0
    
77.                     */
    
78. 
    
79.                    write_inode_now(inode, 1); /*执行这个函数时会不会使进程挂掉????????*/
    
80. 
    
81. 
    
82.                    /* inodes_stat.nr_unused--????为什么这么肯定就能nr_unused--
    
83.                     * 也许inode还有引用
    
84.              */
    
85.                      
    
86.                    spin_lock(&inode_lock);
    
87.                    inodes_stat.nr_unused--;
    
88.                    list_del_init(&inode->i_hash);
    
89.             }
    
90. 
    
91.             list_del_init(&inode->i_list);
    
92.             inode->i_state|=I_FREEING;
    
93.             inodes_stat.nr_inodes--;
    
94.             spin_unlock(&inode_lock);
    
95. 
    
96. 
    
97.             if (inode->i_data.nrpages)
    
98.                     truncate_inode_pages(&inode->i_data, 0);
    
99.             clear_inode(inode);
    
100.      }
     
101. 
     
102. 
     
103. 
     
104. 
     
105. 
     
106. 
     
107. void write_inode_now(struct inode *inode, int sync)
     
108. {
     
109. struct super_block * sb = inode->i_sb;
     
110. 
     
111.      if (sb) {
     
112.            spin_lock(&inode_lock);
     
113.            while (inode->i_state & I_DIRTY)
     
114.            sync_one(inode, sync);
     
115.            spin_unlock(&inode_lock);
     
116. 
     
117.            /* 一旦释放了自旋锁，可能inode马上再次被I_DIRTY，前边自旋锁内的循环前功尽弃。
     
118.         *
     
119.             */
     
120.             if (sync)
     
121.             wait_on_inode(inode);
     
122.        }
     
123.        else
     
124.              printk(KERN_ERR "write_inode_now: no super block\n");
     
125. }
     
126. 
     
127. 
     
128. 
     
129. 
     
130. 
     
131. /* 这时inode->i_count>0，也可能inode->i_count==0,因为在调用write_inode_now前,已经释放了自旋锁
     
132. *
     
133. * 假如这个进程正在被同步中, 设置了I_LOCK, 而i_count==0时，本函数再次iget，iput，又一次执行了 iput，而这次iput时，完全可能会与上一个iput执行相同的路线, 比如说在iput中write_inode_now前的瞬间,SMP上的另一个进程又把这个inode标记为脏,然后又切换进kupdate进程,进程开始同步这个inode,又设置了I_LOCK,而这时i_count==0
     
134. 因此这个进程不会完蛋？？
     
135. */
     
136. static inline void sync_one(struct inode *inode, int sync)
     
137. {
     
138. 
     
139.    while (inode->i_state & I_LOCK) {
     
140.           __iget(inode);
     
141.           spin_unlock(&inode_lock);
     
142.           __wait_on_inode(inode);
     
143.           iput(inode);
     
144.           spin_lock(&inode_lock);
     
145.    }
     
146. 
     
147.     __sync_one(inode, sync);
     
148. }  
     
149. 
     
150. 
     
151. 
     
152. 
     
153. 
     
154. 
     
155. 
     
156. /*  参数( inode ，是否同步)
     
157.   *
     
158.   *  inode 入locked 链,释放自旋锁,执行:
     
159.   *            dirty_page 链换至locked_page，回写
     
160.   *                     inode 回写至磁盘块，等待
     
161.   *            locked_page链换至clean_page 链，等待
     
162.   *  inode 得到自旋锁,清I_LOCK,按优先级顺序选择链
     
163.   */
     
164. static inline void __sync_one(struct inode *inode, int sync)
     
165. {
     
166.         unsigned dirty;
     
167. 
     
168.         /* 对inode 上锁，换链至s_locked_inodes*/
     
169.         list_del(&inode->i_list);
     
170.         list_add(&inode->i_list, &inode->i_sb->s_locked_inodes);
     
171. 
     
172. 
     
173. 
     
174.         if (inode->i_state & (I_LOCK|I_FREEING))
     
175.                 BUG();
     
176. 
     
177.         /* Set I_LOCK, reset I_DIRTY */
     
178.         dirty = inode->i_state & I_DIRTY;
     
179.         inode->i_state |= I_LOCK;
     
180.         inode->i_state &= ~I_DIRTY;
     
181.         spin_unlock(&inode_lock);
     
182. 
     
183. 
     
184.         /* 不判断是否uptodata ，就将address space->dirty_pages 中的页
     
185.           * 转移至locked_pages  链，根据dirty 判断是否不等待的回写
     
186.           */
     
187.         filemap_fdatasync(inode->i_mapping);
     
188. 
     
189. 
     
190.         /* 如果inode 设置了I_DIRTY_SYNC | I_DIRTY_DATASYNC，
     
191.           * 则回写磁盘inode 和超级块
     
192.           *
     
193.           * 顺便等待页回写完成
     
194.           */
     
195.         if (dirty & (I_DIRTY_SYNC | I_DIRTY_DATASYNC))
     
196.                 write_inode(inode, sync);
     
197. 
     
198. 
     
199.         /* 不判断是否uptodata ，就将address space->locked_pages 中的页
     
200.           * 转移至clean_pages  链，根据锁定 判断是否等待
     
201.           */
     
202.         filemap_fdatawait(inode->i_mapping);
     
203. 
     
204.         spin_lock(&inode_lock);
     
205. 
     
206. 
     
207. 
     
208. 
     
209.         /* 对inode 解锁，换链判断顺序为s_dirty_inode，inode->i_count，
     
210.           * inode->i_data.nr_pages，最后万不得已到inode_unused 链  
     
211.           */
     
212.         inode->i_state &= ~I_LOCK;
     
213.         __refile_inode(inode);
     
214.         wake_up(&inode->i_wait);
     
215. }
     
216. 
     

复制代码

我不是高手，你说的对，我就是一个不摸kernel门的人，但却比你强，你看不懂的我懂，你不会的我会。想做Linux内核大陆第一高手，先看看可不可以干掉所有cuer，我就是第一个cuer。

bwater

下战书了