3）宏展开

将对宏的调用展开成相对应的宏定义

关于宏定义还有很多其他的知识点，本文暂不深入展开。

四、如何快速展开复杂的宏定义？

linux内核中通常有很多宏定义，非常的复杂，对于初学者来说，经常会一头雾水，那如何快速理解宏定义呢？

一口君教你一个非常方便的方法，让你直接看透宏定义，我们以上述代码为例：

第一步将要展开的宏先拷贝到c文件中，然后把所有用到的宏定义都拷贝到该文件中；内核中很多的宏都是嵌套的，把嵌套的宏定义都一起拷贝到文件中；此外内核很多的宏会由条件编译决定，从而导致有多种定义方式，如果不确定，就把条件编译一起拷贝过来，

如该例所示，MAX＿NUMNODES 就被嵌套了多级，最终宏CONFIG＿NODES＿SHIFT在内核中没有检索到，所以该宏没有定义。

文件如下：123．c

1
 2
 3 ＃ifdef CONFIG＿NODES＿SHIFT
 4 ＃define NODES＿SHIFT     CONFIG＿NODES＿SHIFT
 5 ＃else
 6 ＃define NODES＿SHIFT     0
 7 ＃endif
 8
 9
10                                                                                                                  
11 ＃define MAX＿NUMNODES    （1 ＜＜ NODES＿SHIFT）
12
13
14
15
16 ＃if MAX＿NUMNODES ＞ 1
17 ＃define for＿each＿node＿state（＿＿node， ＿＿state）
18         for＿each＿node＿mask（（＿＿node）， node＿states［＿＿state］）
19 ＃else
20 ＃define for＿each＿node＿state（node， ＿＿state）
21         for （ （node） ＝ 0； （node） ＝＝ 0； （node） ＝ 1）
22 ＃endif
23
24
25
26
27 ＃define for＿each＿online＿node（node） for＿each＿node＿state（node， N＿ONLINE）
28
29
30 static int ＿＿build＿all＿zonelists（void ＊data）
31 ｛  
32     int nid；
33     int cpu；
34     pg＿data＿t ＊self ＝ data；
35
36    
37
38     for＿each＿online＿node（nid） ｛
39         pg＿data＿t ＊pgdat ＝ NODE＿DATA（nid）；
40
41         build＿zonelists（pgdat）；
42         build＿zonelist＿cache（pgdat）；
43     ｝
44 ｝
第二步

使用以下命令，展开宏定义，

gcc －E

－E的含义是，编译预处理该文件，但是不去生成汇编代码，只把文件中的宏定义以及包含的头文件替代，并不会去检查语法正确与否。

结果如下：

peng＠ubuntu：～／test＄ gcc 123．c －E
＃ 1 ＂123．c＂
＃ 1 ＂＜built－in＞＂
＃ 1 ＂＜command－line＞＂
＃ 1 ＂／usr／include／stdc－predef．h＂ 1 3 4
＃ 1 ＂＜command－line＞＂ 2
＃ 1 ＂123．c＂
＃ 28 ＂123．c＂
static int ＿＿build＿all＿zonelists（void ＊data）
｛
int nid；
int cpu；
pg＿data＿t ＊self ＝ data；
for （ （nid） ＝ 0； （nid） ＝＝ 0； （nid） ＝ 1） ｛
 pg＿data＿t ＊pgdat ＝ NODE＿DATA（nid）；
 build＿zonelists（pgdat）；
 build＿zonelist＿cache（pgdat）；
｝
｝

由结果可知，nid是被赋值为0的。

五、练习

我们来做一个练习，展开一下内核的waite＿event（）这个宏

拷贝用到所有宏定义到c文件中。

wait．c

1
 2 ＃define ＿＿＿wait＿event（wq， condition， state， exclusive， ret， cmd）    
 3     （｛                                  
 4      ＿＿label＿＿ ＿＿out；                      
 5      wait＿queue＿t ＿＿wait；                      
 6      long ＿＿ret ＝ ret；                      
 7      
 8      INIT＿LIST＿HEAD（＆＿＿wait．task＿list）；            
 9      if （exclusive）                        
10      ＿＿wait．flags ＝ WQ＿FLAG＿EXCLUSIVE；          
11      else
12      ｛
13       code                          
14      ＿＿wait．flags ＝ 0；                  
15      
16      for （；；） ｛                        
17      long ＿＿int ＝ prepare＿to＿wait＿event（＆wq， ＆＿＿wait， state）；
18      
19      if （condition）                        
20      break；                    
21      
22      if （＿＿＿wait＿is＿interruptible（state） ＆＆ ＿＿int） ｛        
23      ＿＿ret ＝ ＿＿int；                
24          if （exclusive） ｛              
25              abort＿exclusive＿wait（＆wq， ＆＿＿wait，
26                      state， NULL）；  
27                  goto ＿＿out；                
28          ｝                      
29      break；                    
30      ｝                          
31      
32          cmd；                          
33      ｝                              
34      finish＿wait（＆wq， ＆＿＿wait）；                
35          ＿＿out： ＿＿ret；                              
36      ｝）
37     ｝
38
39
40
41
42 ＃define TASK＿UNINTERRUPTIBLE    2
43
44
45 ＃define ＿＿wait＿event（wq， condition）                
46     （void）＿＿＿wait＿event（wq， condition， TASK＿UNINTERRUPTIBLE， 0， 0，  
47             schedule（））
48
49