linux内核启动第二阶段分析

偏执的太偏执、 2022-03-26 14:08 418阅读 0赞

linux内核启动第二阶段分析

456 asmlinkage void \_\_init start\_kernel(void)  
457 \{  
458         char \* command\_line;  
459         extern const struct kernel\_param \_\_start\_\_\_param\[\], \_\_stop\_\_\_param\[\];这两个外部变量，是内核编译剧本定位的内核参数肇端地址  
460  
461         smp\_setup\_processor\_id(); /\*当只有一个CPU的时候这个函数就什么都不做，但是如果有多个CPU的时候那么它就 返回在启动的时候的那个CPU的号  \*/  
462  
463         /\*  
464          \* Need to run as early as possible, to initialize the  
465          \* lockdep hash:  
466          \*/  
467         lockdep\_init(); /\*初始化lockdep hash 表\*/  
468         debug\_objects\_early\_init();//初始化debug kernel相关  
469  
470         /\*  
471          \* Set up the the initial canary ASAP:  
472          \*/  
473         boot\_init\_stack\_canary();//stack\_canary的是带防止栈溢出攻击保护的堆栈。详见http://www.cloud-sec.org/CC\_STACKPROTECTOR\_patch\_Analysis  
474  
475         cgroup\_init\_early();//Cgroup初始化，Cgroup是近代linux kernel出现的.它为进程和其后续的子进程提供了一种性能控制机制，详见：http://linux.chinaunix.net/techdoc/net/2008/12/23/1054425.shtml  
476  
477         local\_irq\_disable(); /\*关闭当前CPU的中断\*/  
478         early\_boot\_irqs\_disabled = true;  
479  
480 /\*  
481  \* Interrupts are still disabled. Do necessary setups, then  
482  \* enable them  
483  \*/  
484         tick\_init(); //初始化 tick控制功能，注册clockevents的框架。  
485         boot\_cpu\_init();//对于CPU核的系统来说，设置第一个CPU核为活跃  CPU核。对于单CPU核系统来说，设置CPU核为活跃CPU核  
486         page\_address\_init();  
/\*当定义了CONFIG\_HIGHMEM 宏，并且没有定义   WANT\_PAGE\_VIRTUAL 宏时，非空函数。其他情况为空函数。注意：ARM9不支持高端地址（大于896M），一般的嵌入式产品也不会用高端地址，所以，在ARM体系结构下，此函数为空！\*/  
487         printk(KERN\_NOTICE "%s", linux\_banner);/\* 将linux\_banner的内容打印到log\_buf缓冲区中去，等到串口或者其它终端初始化之后，在一次性打印到终端上去\*/  
488         setup\_arch(&command\_line);  
/\*每种体系结构都有自己的setup\_arch()函数，是体系结构相关的，具体编译哪个 体系结构的setup\_arch()函数,由源码树顶层目录下的Makefile中的ARCH变量决定   
  例如： ARM体系结构的。  
  SUBARCH :=arm    
  ARCH        ?= $(SUBARCH)  
该函数在所在的路劲为 /arm/kernel/setup.c，其中那个command\_line就是有bootloader传过来的!这个函数是个重量级的函数，大家不可忽视！该函数完成体系结构相关的初始化，内核移植的过程一般也就到此函数为止了，其余的就只是一些相关的外设驱动。\*/  
489         mm\_init\_owner(&init\_mm, &init\_task);  
490         mm\_init\_cpumask(&init\_mm);  
491         setup\_command\_line(command\_line);/\*保存未改变的comand\_line到字符数组static\_command\_line［］ 中。保存  boot\_command\_line到字符数组saved\_command\_line［］中\*/  
492         setup\_nr\_cpu\_ids();  
493         setup\_per\_cpu\_areas();  /\* 每个CPU分配pre-cpu结构内存并复制.data.percpu段的数据 \*/   
  
494         smp\_prepare\_boot\_cpu(); /\* arch-specific boot-cpu hooks \*/  
495  
496         build\_all\_zonelists(NULL);  
497         page\_alloc\_init();  
498  
499         printk(KERN\_NOTICE "Kernel command line: %s\\n", boot\_command\_line);  
500         parse\_early\_param();  
501         parse\_args("Booting kernel", static\_command\_line, \_\_start\_\_\_param,  
502                    \_\_stop\_\_\_param - \_\_start\_\_\_param,  
503                    &unknown\_bootoption);  
504         /\*  
505          \* These use large bootmem allocations and must precede  
506          \* kmem\_cache\_init()  
507          \*/  
508         setup\_log\_buf(0);  
509         pidhash\_init();  
510         vfs\_caches\_init\_early();  
511         sort\_main\_extable();  
512         trap\_init();  
513         mm\_init();  
514  
515         /\*  
516          \* Set up the scheduler prior starting any interrupts (such as the  
517          \* timer interrupt). Full topology setup happens at smp\_init()  
518          \* time - but meanwhile we still have a functioning scheduler.  
519          \*/  
520         sched\_init();  
521         /\*  
522          \* Disable preemption - early bootup scheduling is extremely  
523          \* fragile until we cpu\_idle() for the first time.  
524          \*/  
525         preempt\_disable();  
526         if (!irqs\_disabled()) \{  
527                 printk(KERN\_WARNING "start\_kernel(): bug: interrupts were "  
528                                 "enabled \*very\* early, fixing it\\n");  
529                 local\_irq\_disable();  
530         \}  
531         idr\_init\_cache();  
532         perf\_event\_init();  
533         rcu\_init();  
534         radix\_tree\_init();  
535         /\* init some links before init\_ISA\_irqs() \*/  
536         early\_irq\_init();  
537         init\_IRQ();  
538         prio\_tree\_init();  
539         init\_timers();  
540         hrtimers\_init();  
541         softirq\_init();  
542         timekeeping\_init();  
543         time\_init();  
544         profile\_init();  
545         call\_function\_init();  
546         if (!irqs\_disabled())  
547                 printk(KERN\_CRIT "start\_kernel(): bug: interrupts were "  
548                                  "enabled early\\n");  
549         early\_boot\_irqs\_disabled = false;  
550         local\_irq\_enable();  
551  
552         /\* Interrupts are enabled now so all GFP allocations are safe. \*/  
553         gfp\_allowed\_mask = \_\_GFP\_BITS\_MASK;  
554  
555         kmem\_cache\_init\_late();  
556  
557         /\*  
558          \* HACK ALERT! This is early. We're enabling the console before  
559          \* we've done PCI setups etc, and console\_init() must be aware of  
560          \* this. But we do want output early, in case something goes wrong.  
561          \*/  
562         console\_init();  
563         if (panic\_later)  
564                 panic(panic\_later, panic\_param);  
565  
566         lockdep\_info();  
567  
568         /\*  
569          \* Need to run this when irqs are enabled, because it wants  
570          \* to self-test \[hard/soft\]-irqs on/off lock inversion bugs  
571          \* too:  
572          \*/  
573         locking\_selftest();  
574  
575 \#ifdef CONFIG\_BLK\_DEV\_INITRD  
576         if (initrd\_start && !initrd\_below\_start\_ok &&  
577             page\_to\_pfn(virt\_to\_page((void \*)initrd\_start)) < min\_low\_pfn) \{  
578                 printk(KERN\_CRIT "initrd overwritten (0x%08lx < 0x%08lx) - "  
579                     "disabling it.\\n",  
580                     page\_to\_pfn(virt\_to\_page((void \*)initrd\_start)),  
581                     min\_low\_pfn);  
582                 initrd\_start = 0;  
583         \}  
584 \#endif  
585         page\_cgroup\_init();  
586         enable\_debug\_pagealloc();  
587         debug\_objects\_mem\_init();  
588         kmemleak\_init();  
589         setup\_per\_cpu\_pageset();  
590         numa\_policy\_init();  
591         if (late\_time\_init)  
592                 late\_time\_init();  
593         sched\_clock\_init();  
594         calibrate\_delay();  
595         pidmap\_init();  
596         anon\_vma\_init();  
597 \#ifdef CONFIG\_X86  
598         if (efi\_enabled)  
599                 efi\_enter\_virtual\_mode();  
600 \#endif  
601         thread\_info\_cache\_init();  
602         cred\_init();  
603         fork\_init(totalram\_pages);  
604         proc\_caches\_init();  
605         buffer\_init();  
606         key\_init();  
607         security\_init();  
608         dbg\_late\_init();  
609         vfs\_caches\_init(totalram\_pages);  
610         signals\_init();  
611         /\* rootfs populating might need page-writeback \*/  
612         page\_writeback\_init();  
613 \#ifdef CONFIG\_PROC\_FS  
614         proc\_root\_init();  
615 \#endif  
616         cgroup\_init();  
617         cpuset\_init();  
618         taskstats\_init\_early();  
619         delayacct\_init();  
620  
621         check\_bugs();  
622  
623         acpi\_early\_init(); /\* before LAPIC and SMP init \*/  
624         sfi\_init\_late();  
625  
626         ftrace\_init();  
627  
628         /\* Do the rest non-\_\_init'ed, we're now alive \*/  
629         rest\_init();  
630 \}  
  
 kernel/lockdep.c  
3757 void lockdep\_init(void)  
3758 \{  
3759         int i;  
3760  
3761         /\*  
3762          \* Some architectures have their own start\_kernel()  
3763          \* code which calls lockdep\_init(), while we also  
3764          \* call lockdep\_init() from the start\_kernel() itself,  
3765          \* and we want to initialize the hashes only once:  
3766          \*/  
3767         if (lockdep\_initialized)  
3768                 return;  
3769  
3770         for (i = 0; i < CLASSHASH\_SIZE; i++)  
3771                 INIT\_LIST\_HEAD(classhash\_table + i);  
3772  
3773         for (i = 0; i < CHAINHASH\_SIZE; i++)  
3774                 INIT\_LIST\_HEAD(chainhash\_table + i);  
3775  
3776         lockdep\_initialized = 1;  
3777 \}  
  
该函数用于启动Lock dependency validator，本质上是建立两个散列表classhash\_table和chainhash\_table，并初始化全局变量lockdep\_initialized。对Linux内核的链表和散列表不熟悉的同志可以看看博客“Linux内核入门（三）—— C语言基本功http://blog.csdn.net/yunsongice/article/details/5471096”的相关内容。  
468行，debug\_objects\_early\_init()函数，用于内核的对象调试。由于我们.config文件中没有配置CONFIG\_DEBUG\_OBJECTS，所以这个函数为空函数。  
468行，调用boot\_init\_stack\_canary()函数，同样在也.config文件中没有配置CONFIG\_CC\_STACKPROTECTOR，所以这个函数也为空。  
473行，boot\_init\_stack\_canary()函数，stack\_canary的是带防止栈溢出攻击保护的堆栈。详见http://www.cloud-sec.org/CC\_STACKPROTECTOR\_patch\_Analysis  
475行，CONFIG\_CGROUPS也没有配置，所以cgroup\_init\_early()函数也为空。  
477行，local\_irq\_disable()，终于不为空了，在include/linux/irqflags.h的92行定义：  
\#define local\_irq\_disable() \\  
    do \{ raw\_local\_irq\_disable(); trace\_hardirqs\_off(); \} while (0)  
59行定义  
\#define raw\_local\_irq\_disable()        arch\_local\_irq\_disable()  
  
注意，这个定义必须是CONFIG\_TRACE\_IRQFLAGS\_SUPPORT编译选项存在于.config文件，该宏才有效。我查了查.config，是存在的，所以又定位到raw\_local\_irq\_disable和trace\_hardirqs\_off两个宏。先看第一个，raw\_local\_irq\_disable，全内核四个地方有定义，取决于一个重要的CONFIG\_PARAVIRT编译选项是否被配置。我们看到.config中根本不存在这个编译选项，所以根本不用考虑arch/x86/include/asm/paravirt.h里面的内容。而剩下的定义来自哪儿，取决于宏\_\_ASSEMBLY\_\_。  
是该讲讲\_\_ASSEMBLY\_\_宏了，这个宏的作用是避免gcc在进行汇编编译的时候，不定义后续相关内容。什么意思？我们看到顶层Makefile有一个：  
375 KBUILD\_AFLAGS   := -D\_\_ASSEMBLY\_\_  
这个宏变量实际上是在编译汇编代码的时候，由编译器使用-D这样的参数加进去的，KBUILD\_AFLAGS这个变量也定义了这个变量，gcc会把这个宏定义为1。我们知道，gcc编译一个c程序大致分为三步：编译c文件生成临时汇编程序；编译汇编程序生成.o对象文件；链接对象文件生成c程序。而KBUILD\_AFLAGS指定\_\_ASSEMBLY\_\_，是为了编译汇编程序时，不会用到类似于“\# define”定义的属性（注意！不是宏定义\#define，\#后面有一个空格，Linux内核中定义了很多这样的定义，在编译c文件时，就相当于\#define），因为这样的属性是在进行C语言编译的时候加的，通过\_\_ASSEMBLY\_\_来避免在C语言编译成汇编程序后，不在编译这些汇编代码时候的引用，从而避免不必要的宏或函数在编译汇编代码时候的引用。  
虽然我们顶层Makefile设置了\_\_ASSEMBLY\_\_，但是，我们现在分析的是c语言下的代码，\_\_ASSEMBLY\_\_暂没定义，所以来到iarch/arm/include/asm/irqflags.h中33行：  
 33 static inline void arch\_local\_irq\_disable(void)  
 34 \{  
 35         asm volatile(  
 36                 "       cpsid i                 @ arch\_local\_irq\_disable"  
 37                 :  
 38                 :  
 39                 : "memory", "cc");  
 40 \}  
调用 cpsid取消eflags的IF标志位，屏蔽可屏蔽中断。有关可屏蔽中断、非屏蔽中断和异常的基本概念请参考博文“中断的分类”。后面由于我们没有设置CONFIG\_TRACE\_IRQFLAGS和CONFIG\_IRQSOFF\_TRACER编译选项，所以trace\_hardirqs\_off()函数为空，回到start\_kernel中。  
**注册时钟事件监听器**  
由于我们在.config文件中设置了CONFIG\_GENERIC\_CLOCKEVENTS，所以，start\_kernel函数的第558行调用kernel/time/tick-common.c中的tick\_init函数，来注册一个时钟事件监听器。tick\_init只调用一个clockevents\_register\_notifier函数：  
407 static struct notifier\_block tick\_notifier = \{  
408         .notifier\_call = tick\_notify,  
409 \};  
  
416 void \_\_init tick\_init(void)  
417 \{  
418         clockevents\_register\_notifier(&tick\_notifier);  
419 \}  
kernel/time/clockevents.c  
138 int clockevents\_register\_notifier(struct notifier\_block \*nb)  
139 \{  
140         unsigned long flags;  
141         int ret;  
142  
143         raw\_spin\_lock\_irqsave(&clockevents\_lock, flags);  
144         ret = raw\_notifier\_chain\_register(&clockevents\_chain, nb);  
145         raw\_spin\_unlock\_irqrestore(&clockevents\_lock, flags);  
146  
147         return ret;  
148 \}  
  
这个函数很简单，只要先明白一个notifier\_block结构就行了：  
struct notifier\_block \{  
       int (\*notifier\_call)(struct notifier\_block \*, unsigned long, void \*);  
       struct notifier\_block \*next;  
       int priority;  
\};  
  
tick\_notifier全局变量在编译vmlinux的时候其notifier\_call被设置成了tick\_notify函数：  
kernel/time/tick-common.c  
362 static int tick\_notify(struct notifier\_block \*nb, unsigned long reason,  
363                                void \*dev)  
364 \{  
365         switch (reason) \{  
366  
367         case CLOCK\_EVT\_NOTIFY\_ADD:  
368                 return tick\_check\_new\_device(dev);  
369  
370         case CLOCK\_EVT\_NOTIFY\_BROADCAST\_ON:  
371         case CLOCK\_EVT\_NOTIFY\_BROADCAST\_OFF:  
372         case CLOCK\_EVT\_NOTIFY\_BROADCAST\_FORCE:  
373                 tick\_broadcast\_on\_off(reason, dev);  
374                 break;  
375  
376         case CLOCK\_EVT\_NOTIFY\_BROADCAST\_ENTER:  
377         case CLOCK\_EVT\_NOTIFY\_BROADCAST\_EXIT:  
378                 tick\_broadcast\_oneshot\_control(reason);  
379                 break;  
380  
381         case CLOCK\_EVT\_NOTIFY\_CPU\_DYING:  
382                 tick\_handover\_do\_timer(dev);  
383                 break;  
384  
385         case CLOCK\_EVT\_NOTIFY\_CPU\_DEAD:  
386                 tick\_shutdown\_broadcast\_oneshot(dev);  
387                 tick\_shutdown\_broadcast(dev);  
388                 tick\_shutdown(dev);  
389                 break;  
390  
391         case CLOCK\_EVT\_NOTIFY\_SUSPEND:  
392                 tick\_suspend();  
393                 tick\_suspend\_broadcast();  
394                 break;  
395  
396         case CLOCK\_EVT\_NOTIFY\_RESUME:  
397                 tick\_resume();  
398                 break;  
399  
400         default:  
401                 break;  
402         \}  
403  
404         return NOTIFY\_OK;  
405 \}  
这上面一串函数是什么意思？这里要学一个新知识——通知链技术。我们知道内核一些驱动或文件系统是被编译成模块了的，当某个模块的某些事件对其模块是很有用的，则本模块应该定义一个通知链，并导出接口。那么其它模块对其事件感兴趣时，可以调用这些接口注册（注销）当事件发生时的行为。而本模块在事件发生时，调用通知其链上的所有订阅者（调用其函数）。而这个notifier\_block就是通知链中的元素，记录了当发出通知时，应该执行的操作（即回调函数）。这里tick\_notifier是一个时钟事件监听器模块，当发出通知是，就执行tick\_notify函数。所以，clockevents\_register\_notifier函数就调用raw\_notifier\_chain\_register来注册，其实就是把三步：获得自旋锁、把tick\_notifier加入clockevents\_chain、释放自旋锁。  
  
**激活第一个CPU**  
回到start\_kernel，485行，boot\_cpu\_init函数，跟start\_kernel位于同一文件：  
421 static void \_\_init boot\_cpu\_init(void)  
422 \{  
423         int cpu = smp\_processor\_id();  
424         /\* Mark the boot cpu "present", "online" etc for SMP and UP case \*/  
425         set\_cpu\_online(cpu, true);  
426         set\_cpu\_active(cpu, true);  
427         set\_cpu\_present(cpu, true);  
428         set\_cpu\_possible(cpu, true);  
429 \}  
423行，第一次见到smp\_processor\_id宏。由于没有配置CONFIG\_DEBUG\_PREEMPT，所以其等价于调用宏raw\_smp\_processor\_id，其意义在于SMP的情况下，获得当前CPU的ID。如果不是SMP，那么就返回0。那么在CONFIG\_X86\_32\_SMP的情况下：  
  
\#define raw\_smp\_processor\_id() (percpu\_read(cpu\_number))  
千万要注意，这里cpu\_number来自arch/x86/kernel/setup\_percpu.c的30行：  
  
  30DEFINE\_PER\_CPU(int, cpu\_number);  
  31EXPORT\_PER\_CPU\_SYMBOL(cpu\_number);  
  
这个东西不像是c语言全局变量，而是通过两个宏来定义的。要读懂这两个宏，必须对每CPU变量这个概念非常了解，如果还不是很清楚的同学请查阅一下博客“每CPU变量”http://blog.csdn.net/yunsongice/archive/2010/05/18/5605239.aspx。  
其中DEFINE\_PER\_CPU来自文件include/linux/percpu-defs.h：  
\#define DEFINE\_PER\_CPU(type, name)                                /  
       DEFINE\_PER\_CPU\_SECTION(type, name, "")  
该宏静态分配一个每CPU数组，数组名为name，结构类型为type。由于我们没有设置CONFIG\_DEBUG\_FORCE\_WEAK\_PER\_CPU编译选项，所以DEFINE\_PER\_CPU\_SECTION又被定义为：  
\#define DEFINE\_PER\_CPU\_SECTION(type, name, sec)                       /  
       \_\_PCPU\_ATTRS(sec) PER\_CPU\_DEF\_ATTRIBUTES                    /  
       \_\_typeof\_\_(type) name  
  
其中，\_\_PCPU\_ATTRS(sec)在include/linux/percpu-defs.h中定义：  
\#define \_\_PCPU\_ATTRS(sec)                                          /  
       \_\_percpu \_\_attribute\_\_((section(PER\_CPU\_BASE\_SECTION sec))) /  
       PER\_CPU\_ATTRIBUTES  
\_\_percpu是个编译扩展类型，大家可以去看看include/linux/compile.h这个文件，里面的\_\_percpu是空的。而传进来的sec也是空的，PER\_CPU\_ATTRIBUTES也是空的，而上面PER\_CPU\_DEF\_ATTRIBUTES还是空代码，可能都是留给将来内核代码扩展之用的吧，所以DEFINE\_PER\_CPU(int, cpu\_number)展开就是：  
\_\_attribute\_\_((section(PER\_CPU\_BASE\_SECTION)))       /  
\_\_typeof\_\_(int) cpu\_number  
所以现在只关注PER\_CPU\_BASE\_SECTION，来自include/asm-generic/percpu.h  
  
\#ifdef CONFIG\_SMP  
\#define PER\_CPU\_BASE\_SECTION ".data.percpu"  
\#else  
\#define PER\_CPU\_BASE\_SECTION ".data"  
\#endif  
   
好了，介绍一下GCC的一些扩展，首先如何使用typeof来支持一些“genericprogramming”。gcc支持一种叫做类型识别的技术，通过typeof(x)关键字，获得x的数据类型。而如果是在一个要被一些c文件包含的头文件中获得变量的数据类型，就需要用\_\_typeof\_\_而不是typeof关键字了，比如说我们这里。最后，这里就是声明一个int类型的cpu\_number指针，编译的时候把他指向.data.percpu段的开始位置。  
  
当然，我们自己写程序的时候没有这么地generic programming，所以没必要这么做，不过想要成为一个内核达人，掌握这些技术还是很有必要的。DEFINE\_PER\_CPU\_SECTION宏又是什么意思呢？定义在arch/x86/kernel/percpu-defs.h的147行：  
\#define EXPORT\_PER\_CPU\_SYMBOL(var) EXPORT\_SYMBOL(var)  
   
EXPORT\_SYMBOL是什么东西啊？还记得我们在编译内核时有个kallsyms目标么？这里就用到了。所以我说过，内核的编译过程很重要，请大家务必掌握！这个对象对应于“/proc/kallsyms”文件，该文件对应着内核符号表，记录了符号以及符号所在的内存地址。模块可以使用如下宏导出符号到内核符号表：  
EXPORT\_SYMBOL(符号名);  
EXPORT\_SYMBOL\_GPL(符号名)  
   
导出的符号可以被其他模块使用，不过使用之前一定要声明一下。EXPORT\_SYMBOL\_GPL()只适用于包含GPL许可权的模块。所以，EXPORT\_SYMBOL(cpu\_number)就是把cpu\_number变量声明出去。接下来重点介绍一下percpu\_read这个宏，来自arch/x86/include/asm/percpu.h：  
\#define percpu\_read(var)             percpu\_from\_op("mov", var, "m" (var))  
  
看到mov，我们就知道可能要调用汇编语言了，所以这个宏调用percpu\_from\_op("mov", cpu\_number, "m" (cpu\_number))，这个宏位于同一个文件：  
\#define percpu\_from\_op(op, var, constraint)        \\  
(\{                            \\  
    typeof(var) pfo\_ret\_\_;                \\  
    switch (sizeof(var)) \{                \\  
    case 1:                        \\  
        asm(op "b "\_\_percpu\_arg(1)",%0"        \\  
            : "=q" (pfo\_ret\_\_)            \\  
            : constraint);            \\  
        break;                    \\  
    case 2:                        \\  
        asm(op "w "\_\_percpu\_arg(1)",%0"        \\  
            : "=r" (pfo\_ret\_\_)            \\  
            : constraint);            \\  
        break;                    \\  
    case 4:                        \\  
        asm(op "l "\_\_percpu\_arg(1)",%0"        \\  
            : "=r" (pfo\_ret\_\_)            \\  
            : constraint);            \\  
        break;                    \\  
    case 8:                        \\  
        asm(op "q "\_\_percpu\_arg(1)",%0"        \\  
            : "=r" (pfo\_ret\_\_)            \\  
            : constraint);            \\  
        break;                    \\  
    default: \_\_bad\_percpu\_size();            \\  
    \}                        \\  
    pfo\_ret\_\_;                    \\  
\})  
当然，我们为了获得CPU号，cpu\_number用一个字节就够了，所以上面代码翻译过来就是：  
asm("movb "\_\_percpu\_arg(1)",%0"         /  
     : "=q" (pfo\_ret\_\_)                  /  
     : constraint);  
  
其中，\_\_percpu\_arg(1)是这样定义的：  
\#ifdef CONFIG\_SMP  
\#define \_\_percpu\_arg(x)              "%%"\_\_stringify(\_\_percpu\_seg)":%P" \#x  
  
\#ifdef CONFIG\_X86\_64  
\#define \_\_percpu\_seg           gs  
\#define \_\_percpu\_mov\_op           movq  
\#else  
\#define \_\_percpu\_seg           fs  
\#define \_\_percpu\_mov\_op           movl  
\#endif  
  
所以\_\_percpu\_arg(x)翻译过来就是：  
"%%"\_\_stringify(fs)":%P" \#x  
  
请注意，这是大家第一次遇到这样的定义方式，跟我们传统的C语言宏不一样了。不错，这里要学习新知识了，首先讲讲关于\#和\#\#的知识。  
在C语言的宏中，\#的功能是将其后面的宏参数进行字符串化操作（Stringfication），简单说就是在对它所引用的宏变量通过替换后在其左右各加上一个双引号。比如\_\_percpu\_arg宏：  
\#define \_\_percpu\_arg(x)              "%%"\_\_stringify(\_\_percpu\_seg)":%P" \#x  
而x，我们传入的是1；\_\_percpu\_seg，我们传入的是fs，所以\_\_percpu\_arg展开：  
%%"\_\_stringify(fs)":%P" "1"  
   
而\#\#，虽然这里没有用到，但是我还是一并讲讲，供大家扩充c语言知识。\#\#被称为连接符（concatenator），用来将两个Token连接为一个Token。注意这里连接的对象是Token就行，而不一定是宏的变量。比如：  
\#define LINK\_MULTIPLE(a,b,c,d) a\#\#\_\#\#b\#\#\_\#\#c\#\#\_\#\#d  
typedef struct record\_type LINK\_MULTIPLE(name,company,position,salary);  
这里这个语句将展开为：  
typedef struct record\_type name\_company\_position\_salary;  
   
再来一个新知识，可变参数宏，于1999年的ISO C标准中定义，也就十年前而已。我们看到这里用到了\_\_stringify宏，其定义是这样的：  
\#define \_\_stringify(x...) \_\_stringify\_1(x)  
   
其中…为可变参数，什么意思？就是这个宏除x以外，还可以有额外的多个参数。另外，如果是可变参数宏，那么可变参数x可能会展开为多个参数，那么比如上面也可定义为：  
\#define \_\_stringify(...)   my\_\_stringify(y,z)  0  
不过如果指定了参数名x，则后者必须包含一个x：  
\#define \_\_stringify(x...) my\_\_stringify(x,y,z)  
  
那么我要问了，如果我定义成上面三个参数的形式，但是给的却又只有两个参数怎么办？比如执行一个\_\_stringify(a,b)语句，会不会出错？当然会！因为既然是可变参数的宏，那么传递进去一个空参数也是对的啊，只不过你得有多余的逗号啊，也就是\_\_stringify(,a,b)这样。  
   
不过GCC还有一个东西可以避免这样的“bug”，那就是\#\#符号。如果我们定义成：  
\#define \_\_stringify(x...) my\_\_stringify(\#\#x,y,z)  
这时，\#\#这个连接符号充当的作用就是当x为空的时候，消除前面的那个逗号，这样就不会有上面的bug了。  
  
所以宏：  
\#define \_\_stringify\_1(x...)    \#x  
我们就可以看懂了吧，  
所以\_\_percpu\_arg(1)最终翻译过来就是：  
"%%" "fs:%P" "1"  
因此上边的汇编代码翻译过来就是：  
asm("movb %%fs:%P1, %0"         /  
     : "=q" (pfo\_ret\_\_)                  /  
     : "m" (var));  
   
其中pfo\_ret\_\_是输出部%0，q，表示寄存器eax、ebx、ecx或edx中的一个，并且变量pfo\_ret\_\_存放在这个寄存器中。var就是刚才我们建立的那个临时的汇编变量cpu\_number，作为输入部%1。  
   
还记得“加载全局/中断描述符表”中把\_\_KERNEL\_PERCPU段选择子赋给了fs了吗，不错，fs: cpu\_number就获得了当前存放在\_\_KERNEL\_PERCPU段中cpu\_number偏移的内存中，最后把结果返回给pfo\_ret\_\_。所以这个宏最后的结果就是pfo\_ret\_\_的值，其返回的是CPU的编号，把它赋给boot\_cpu\_init函数的内部变量cpu。  
  
那么这个偏移cpu\_number到底是多少呢？众里寻他千百度，猛回首，这个偏移在生成的vmlinux.lds文件的504行被我发现了：  
\_\_per\_cpu\_load = .; .data.percpu 0  
  
不错，刚才.data.percpu处被编译成0，所以内部cpu的值就是0。我为什么把这一部分讲得这么详细呢，因为这部分内容包含了很多内核代码的细节，以后遇到同样的问题我们就照这样的方法来分析，举一反三。随后的四个函数set\_cpu\_online、set\_cpu\_active、set\_cpu\_present和set\_cpu\_possible我不想多说了，就是激活当前CPU的cpu\_present\_bits中四个标志位online、active、present和possible，感兴趣的同学可以通过上面学到的方法去详细分析。  
**初始化地址散列表**  
486行，page\_address\_init()函数，来自mm/highmem.c：  
418 void \_\_init page\_address\_init(void)  
419 \{  
420         int i;  
421  
422         INIT\_LIST\_HEAD(&page\_address\_pool);  
423         for (i = 0; i < ARRAY\_SIZE(page\_address\_maps); i++)  
424                 list\_add(&page\_address\_maps\[i\].list, &page\_address\_pool);  
425         for (i = 0; i < ARRAY\_SIZE(page\_address\_htable); i++) \{  
426                 INIT\_LIST\_HEAD(&page\_address\_htable\[i\].lh);  
427                 spin\_lock\_init(&page\_address\_htable\[i\].lock);  
428         \}  
429         spin\_lock\_init(&pool\_lock);  
430 \}  
这个函数很简单，首先422初始化一个链表page\_address\_pool，这个链表在编译的时候被定义成一个全局变量在同一个文件的318行：  
318 static struct list\_head page\_address\_pool;  
423行，page\_address\_maps也是个全局变量，来自同一个文件：  
416 static struct page\_address\_map page\_address\_maps\[LAST\_PKMAP\];  
其每一个元素是一个page\_address\_map结构：  
struct page\_address\_map \{  
       struct page \*page;  
       void \*virtual;  
       struct list\_head list;  
\};  
  
OK，第一次见到我们熟悉的page数据结构了。一个page代表一个物理页面，想要深入了解这方面知识的请访问博客“Linux页框管理”http://blog.csdn.net/yunsongice/archive/2010/01/22/5224494.aspx。  
ARRAY\_SIZE获得数组的元素个数，这里肯定就是LAST\_PKMAP了，由于我们没有启动PAE，这个值等于1024，也就是说page\_address\_maps共有1024个元素。随后424行，1024个循环以后，page\_address\_pool通过每个page\_address\_maps的元素的list字段将他们全部链接起来形成个双向循环链表，又page\_address\_pool作为head。  
  
425行，page\_address\_htable，也定义于同一文件：  
324 static struct page\_address\_slot \{  
325         struct list\_head lh;                    /\* List of page\_address\_maps \*/  
326         spinlock\_t lock;                        /\* Protect this bucket's list \*/  
327 \} \_\_\_\_cacheline\_aligned\_in\_smp page\_address\_htable\[1<<PA\_HASH\_ORDER\];  
  
  
\_\_\_\_cacheline\_aligned\_in\_smp是一个编译优化选项，用于SMP方式的缓存优化。PA\_HASH\_ORDER被定义为7，所以2^7=128。所以ARRAY\_SIZE(page\_address\_htable)为128，那么经过128个循环以后，每个page\_address\_htable元素的lh都被初始化成一个链表头了，而对于的互斥锁lock也通过spin\_lock\_init函数进行初始化了。具体的初始化过程请查阅博客“Linux内核入门（三）—— C语言基本功”以及“自旋锁”。  
http://blog.csdn.net/yunsongice/article/details/5471096  http://blog.csdn.net/yunsongice/article/details/5605264  
  
最后page\_address\_pool的自旋锁pool\_lock初始化之后，函数就结束了。简单归简单，但是大家必须知道这个函数的意义。我们知道一个page结构代表一个4k的页面，我们内核初始化这么一个全局的page\_address\_maps和page\_address\_htable这么两个结构，作为页面的地址映射。  
**打印版本信息**  
487行，执行一个printk函数。start\_kernel()开始执行至此，会显示“Linux version 3.0…”信息。  
我们来简单的看看在内核中，在屏幕上打印一条信息的原理是怎么实现的。由于我们配置了CONFIG\_PRINTK编译选项，所以调用位于kernel/printk.c中的printk函数：  
linkage int printk(const char \*fmt, ...)  
\{  
    va\_list args;  
    int r;  
  
\#ifdef CONFIG\_KGDB\_KDB  
    if (unlikely(kdb\_trap\_printk)) \{  
        va\_start(args, fmt);  
        r = vkdb\_printf(fmt, args);  
        va\_end(args);  
        return r;  
    \}  
\#endif  
    va\_start(args, fmt);  
    r = vprintk(fmt, args);  
    va\_end(args);  
  
    return r;  
\}  
又看到了“…”，不错，跟刚才讲的可变参数宏差不多，只不过这里是可变参函数。那么start\_kernel中调用的printk(KERN\_NOTICE "%s", linux\_banner)，其中linux\_banner是个全局字符串常量，定义在init/version.c：  
  
const char linux\_banner\[\] =  
       "Linux version " UTS\_RELEASE " (" LINUX\_COMPILE\_BY "@"  
       LINUX\_COMPILE\_HOST ") (" LINUX\_COMPILER ") " UTS\_VERSION "/n";  
上面那些大写的东西都在我们顶层Makefile中定义过了，就是一些版本信息，整个函数的功能没有问题，我们主要关注本质。所以来看看va\_start、vprintk和va\_end是怎么协作的。  
  
首先，va\_list并不是一个什么复杂的数据结构，而是：  
typedef char \*va\_list;  
仅仅就是一个char\*。所以，根据va\_start的定义：  
\#define \_bnd(X, bnd)            (((sizeof (X)) + (bnd)) & (~(bnd)))  
\#define va\_arg(ap, T)         /  
  (\*(T \*)(((ap) += (\_bnd (T, \_AUPBND))) - (\_bnd (T,\_ADNBND))))  
这就是一个可变参数的调整。调整好以后，我们就可以使用它了。  
 826 asmlinkage int vprintk(const char \*fmt, va\_list args)  
 827 \{  
 828         int printed\_len = 0;  
 829         int current\_log\_level = default\_message\_loglevel;  
 830         unsigned long flags;  
 831         int this\_cpu;  
 832         char \*p;  
 833         size\_t plen;  
 834         char special;  
 835  
 836         boot\_delay\_msec();  
 837         printk\_delay();  
 838  
 839         preempt\_disable();  
 840         /\* This stops the holder of console\_sem just where we want him \*/  
 841         raw\_local\_irq\_save(flags);  
 842         this\_cpu = smp\_processor\_id();  
 843  
 844         /\*  
 845          \* Ouch, printk recursed into itself!  
 846          \*/  
 847         if (unlikely(printk\_cpu == this\_cpu)) \{  
 848                 /\*  
 849                  \* If a crash is occurring during printk() on this CPU,  
 850                  \* then try to get the crash message out but make sure  
 851                  \* we can't deadlock. Otherwise just return to avoid the  
 852                  \* recursion and return - but flag the recursion so that  
 853                  \* it can be printed at the next appropriate moment:  
 854                  \*/  
 855                 if (!oops\_in\_progress) \{  
 856                         recursion\_bug = 1;  
 857                         goto out\_restore\_irqs;  
 858                 \}  
 859                 zap\_locks();  
 860         \}  
 861  
 862         lockdep\_off();  
 863         spin\_lock(&logbuf\_lock);  
 864         printk\_cpu = this\_cpu;  
 865  
 866         if (recursion\_bug) \{  
 867                 recursion\_bug = 0;  
 868                 strcpy(printk\_buf, recursion\_bug\_msg);  
 869                 printed\_len = strlen(recursion\_bug\_msg);  
 870         \}  
 871         /\* Emit the output into the temporary buffer \*/  
 872         printed\_len += vscnprintf(printk\_buf + printed\_len,  
 873                                   sizeof(printk\_buf) - printed\_len, fmt, args);  
 874  
 875         p = printk\_buf;  
 876  
 877         /\* Read log level and handle special printk prefix \*/  
 878         plen = log\_prefix(p, &current\_log\_level, &special);  
 879         if (plen) \{  
 880                 p += plen;  
 881  
 882                 switch (special) \{  
 883                 case 'c': /\* Strip <c> KERN\_CONT, continue line \*/  
 884                         plen = 0;  
 885                         break;  
 886                 case 'd': /\* Strip <d> KERN\_DEFAULT, start new line \*/  
 887                         plen = 0;  
 888                 default:  
 889                         if (!new\_text\_line) \{  
 890                                 emit\_log\_char('\\n');  
 891                                 new\_text\_line = 1;  
 892                         \}  
 893                 \}  
 894         \}  
 895  
 896         /\*  
 897          \* Copy the output into log\_buf. If the caller didn't provide  
 898          \* the appropriate log prefix, we insert them here  
 899          \*/  
 900         for (; \*p; p++) \{  
 901                 if (new\_text\_line) \{  
 902                         new\_text\_line = 0;  
 903  
 904                         if (plen) \{  
 905                                 /\* Copy original log prefix \*/  
 906                                 int i;  
 907  
 908                                 for (i = 0; i < plen; i++)  
 909                                         emit\_log\_char(printk\_buf\[i\]);  
 910                                 printed\_len += plen;  
 911                         \} else \{  
 912                                 /\* Add log prefix \*/  
 913                                 emit\_log\_char('<');  
 914                                 emit\_log\_char(current\_log\_level + '0');  
 915                                 emit\_log\_char('>');  
 916                                 printed\_len += 3;  
 917                         \}  
 918  
 919                         if (printk\_time) \{  
 920                                 /\* Add the current time stamp \*/  
 921                                 char tbuf\[50\], \*tp;  
 922                                 unsigned tlen;  
 923                                 unsigned long long t;  
 924                                 unsigned long nanosec\_rem;  
 925  
 926                                 t = cpu\_clock(printk\_cpu);  
 927                                 nanosec\_rem = do\_div(t, 1000000000);  
 928                                 tlen = sprintf(tbuf, "\[%5lu.%06lu\] ",  
 929                                                 (unsigned long) t,  
 930                                                 nanosec\_rem / 1000);  
 931  
 932                                 for (tp = tbuf; tp < tbuf + tlen; tp++)  
 933                                         emit\_log\_char(\*tp);  
 934                                 printed\_len += tlen;  
 935                         \}  
 936  
 937                         if (!\*p)  
 938                                 break;  
 939                 \}  
 940  
 941                 emit\_log\_char(\*p);  
 942                 if (\*p == '\\n')  
 943                         new\_text\_line = 1;  
 944         \}  
 945  
 946         /\*  
 947          \* Try to acquire and then immediately release the  
 948          \* console semaphore. The release will do all the  
 949          \* actual magic (print out buffers, wake up klogd,  
 950          \* etc).  
 951          \*  
 952          \* The console\_trylock\_for\_printk() function  
 953          \* will release 'logbuf\_lock' regardless of whether it  
 954          \* actually gets the semaphore or not.  
 955          \*/  
 956         if (console\_trylock\_for\_printk(this\_cpu))  
 957                 console\_unlock();  
 958  
 959         lockdep\_on();  
 960 out\_restore\_irqs:  
 961         raw\_local\_irq\_restore(flags);  
 962  
 963         preempt\_enable();  
 964         return printed\_len;  
 965 \}  
 966 EXPORT\_SYMBOL(printk);  
 967 EXPORT\_SYMBOL(vprintk);  
vprintk是个大家伙！该函数负责解析并组成打印格式。836~872行是几个必要的操作，这几个函数都是跟同步互斥以及调试相关。872行，调用vscnprintf将打印信息拷贝到printk\_buf缓存中。比如printk("%d, %s", 5, "hello")，printk\_buf中将是5，hello格式化后的数据不带'/0'。  
随后，p指向这个缓存，存放着linux\_banner对应的字符串。878,879行，根据linux\_banner的第一个字符“<”，识别log级别，否则直接到900行进入一个循环。909行emit\_log\_char函数是将打印信息已经保存到log\_buf中，这个log\_buf有什么用，待会再说。  
919行，printk\_time，由于没有定义CONFIG\_PRINTK\_TIME宏 printk\_time = 0，所以忽略919到935行代码。好了，941行，打印信息已经保存到log\_buf中了，最后957行调用console\_unlock()函数启动console输出。  
注意，我们这里分析的printk和printf不同。回顾一下，他首先输出到系统的一个缓冲区内，大约4k，如果登记了console，则调用console->wirte函数输出，否则就一直在buffer里呆着。所以，用printk输出的信息，如果超出了4k，会冲掉前面的。在系统引导起来后，用dmesg看的也就是这个buffer中的东西。  
此时的信息还在buf中躺着呢，因为console还没有初始化。  
static size\_t log\_prefix(const char \*p, unsigned int \*level, char \*special)  
\{  
    unsigned int lev = 0;  
    char sp = '\\0';  
    size\_t len;  
  
    if (p\[0\] != '<' || !p\[1\])  
        return 0;  
    if (p\[2\] == '>') \{  
        /\* usual single digit level number or special char \*/  
        switch (p\[1\]) \{  
        case '0' ... '7':  
            lev = p\[1\] - '0';  
            break;  
        case 'c': /\* KERN\_CONT \*/  
        case 'd': /\* KERN\_DEFAULT \*/  
            sp = p\[1\];  
            break;  
        default:  
            return 0;  
        \}  
        len = 3;  
    \} else \{  
        /\* multi digit including the level and facility number \*/  
        char \*endp = NULL;  
  
        if (p\[1\] < '0' && p\[1\] > '9')  
            return 0;  
  
        lev = (simple\_strtoul(&p\[1\], &endp, 10) & 7);  
        if (endp == NULL || endp\[0\] != '>')  
            return 0;  
        len = (endp + 1) - p;  
    \}  
  
    /\* do not accept special char if not asked for \*/  
    if (sp && !special)  
        return 0;  
  
    if (special) \{  
        \*special = sp;  
        /\* return special char, do not touch level \*/  
        if (sp)  
            return len;  
    \}  
  
    if (level)  
        \*level = lev;  
    return len;  
\}  
**执行setup\_arch()函数**  
回到start\_kernel当中，488行，调用setup\_arch函数，传给他的参数是那个未被初始化的内部变量command\_line。这个setup\_arch()函数是start\_kernel阶段最重要的一个函数，每个体系都有自己的setup\_arch()函数，是体系结构相关的，具体编译哪个体系的setup\_arch()函数，由顶层Makefile中的ARCH变量决定：  
arch/arm/kernel/setup.c  
 877 void \_\_init setup\_arch(char \*\*cmdline\_p)  
 878 \{  
 879         struct machine\_desc \*mdesc;  
 880  
 881         unwind\_init();  
 882  
 883         setup\_processor();  
 884         mdesc = setup\_machine\_fdt(\_\_atags\_pointer);  
 885         if (!mdesc)  
 886                 mdesc = setup\_machine\_tags(machine\_arch\_type);  
 887         machine\_desc = mdesc;  
 888         machine\_name = mdesc->name;  
 889  
 890         if (mdesc->soft\_reboot)  
 891                 reboot\_setup("s");  
 892  
 893         init\_mm.start\_code = (unsigned long) \_text;  
 894         init\_mm.end\_code   = (unsigned long) \_etext;  
 895         init\_mm.end\_data   = (unsigned long) \_edata;  
 896         init\_mm.brk        = (unsigned long) \_end;  
 897  
 898         /\* populate cmd\_line too for later use, preserving boot\_command\_line \*/  
 899         strlcpy(cmd\_line, boot\_command\_line, COMMAND\_LINE\_SIZE);  
 900         \*cmdline\_p = cmd\_line;  
 901  
 902         parse\_early\_param();  
 903  
 904         sanity\_check\_meminfo();  
 905         arm\_memblock\_init(&meminfo, mdesc);  
 906  
 907         paging\_init(mdesc);  
 908         request\_standard\_resources(mdesc);  
 909  
 910         unflatten\_device\_tree();  
 911  
 912 \#ifdef CONFIG\_SMP  
 913         if (is\_smp())  
 914                 smp\_init\_cpus();  
 915 \#endif  
 916         reserve\_crashkernel();  
 917  
 918         cpu\_init();  
 919         tcm\_init();  
 920  
 921 \#ifdef CONFIG\_MULTI\_IRQ\_HANDLER  
 922         handle\_arch\_irq = mdesc->handle\_irq;  
 923 \#endif  
 924  
 925 \#ifdef CONFIG\_VT  
 926 \#if defined(CONFIG\_VGA\_CONSOLE)  
 927         conswitchp = &vga\_con;  
 928 \#elif defined(CONFIG\_DUMMY\_CONSOLE)  
 929         conswitchp = &dummy\_con;  
 930 \#endif  
 931 \#endif  
 932         early\_trap\_init();  
 933  
 934         if (mdesc->init\_early)  
 935                 mdesc->init\_early();  
 936 \}