linux内核启动第二阶段之setup_arch()函数分析-2.6.36

比眉伴天荒 2022-03-26 14:08 235阅读 0赞

**执行setup\_arch()函数**  
回到start\_kernel当中，569行，调用setup\_arch函数，传给他的参数是那个未被初始化的内部变量command\_line。这个setup\_arch()函数是start\_kernel阶段最重要的一个函数，每个体系都有自己的setup\_arch()函数，是体系结构相关的，具体编译哪个体系的setup\_arch()函数，由顶层Makefile中的ARCH变量决定：  
它首先通过检测出来的处理器类型进行处理器内核的初始化，然后通过 bootmem\_init()函数根据系统定义的 meminfo 结构进行内存结构的初始化，最后调用paging\_init()开启 MMU，创建内核页表，映射所有的物理内存和 IO空间。  
start\_kernel ()  
    --> setup\_arch ()  
       --> paging\_init ()  
          --> bootmem\_init ()  
              --> alloc\_bootmem\_low\_pages ()  
第569行setup\_arch(&command\_line)在arch/arm/kernel/setup.c定义如下：  
767 void \_\_init setup\_arch(char \*\*cmdline\_p)  
768 \{  
769         struct tag \*tags = (struct tag \*)&init\_tags;  
770         struct machine\_desc \*mdesc;  
771         char \*from = default\_command\_line;  
772  
773         unwind\_init();  
774  
775         setup\_processor();  
776         mdesc = setup\_machine(machine\_arch\_type);  
777         machine\_name = mdesc->name;  //machine\_name在126行定义static const char \*machine\_name;  
778  
779         if (mdesc->soft\_reboot)   //这个变量初始值为"h",如果这里设置成softboot，它会将这个初始值变为"s"  
780                 reboot\_setup("s");  
781  
782         if (\_\_atags\_pointer) //检查BootLoader是否传入参数  
783                 tags = phys\_to\_virt(\_\_atags\_pointer);  
784         else if (mdesc->boot\_params)//machine descriptor中设置的启动参数地址(arch/arm/mach-s3c2410/mach-smdk2410.c)  
785                 tags = phys\_to\_virt(mdesc->boot\_params);  
786  
787 \#if defined(CONFIG\_DEPRECATED\_PARAM\_STRUCT)  
788         /\*  
789          \* If we have the old style parameters, convert them to  
790          \* a tag list.  
791          \*/  
792         if (tags->hdr.tag != ATAG\_CORE)//内核参数列表第一项必须是ATAG\_CORE类型，如果不是，则需要转换成新的内核参数类型，新的内核参数类型用下面 struct tag结构表示,由bootloader\[u-boot-1.1.5\]传递到物理地址0x30000100处的参数类型是tag list结构,在u-boot-1.1.6后是采用了新的内核参数类型struct tag结构  
793                 convert\_to\_tag\_list(tags);//此函数完成新旧参数结构转换，将参数结构转换为tag list结构  
794 \#endif  
795         if (tags->hdr.tag != ATAG\_CORE)//如果没有内核参数  
796                 tags = (struct tag \*)&init\_tags;//则选用默认的内核参数，init\_tags文件中有定义。  
797  
798         if (mdesc->fixup)  //用内核参数列表填充meminfo，fixup函数出现在注册machine\_desc中，即MACHINE\_START、MACHINE\_END定义中，这个函数，有些板子有，但在2410中没有定义这个函数。  
799                 mdesc->fixup(mdesc, tags, &from, &meminfo);  
800  
801         if (tags->hdr.tag == ATAG\_CORE) \{  
802                 if (meminfo.nr\_banks != 0) //说明内存被初始化过  
803                         squash\_mem\_tags(tags);//如果是tag list,那么如果系统已经创建了默认的meminfo.nr\_banks，清除tags中关于MEM的参数，以免再次被初始化  
804                 save\_atags(tags);  
805                 parse\_tags(tags);//做出一些针对各个tags的处理  
806         \}  
807         //下面是记录内核代码的起始，结束虚拟地址  
808         init\_mm.start\_code = (unsigned long) \_text;  
809         init\_mm.end\_code   = (unsigned long) \_etext;  
810         init\_mm.end\_data   = (unsigned long) \_edata;  
811         init\_mm.brk        = (unsigned long) \_end;  
812  
813         /\* parse\_early\_param needs a boot\_command\_line \*/  
814         strlcpy(boot\_command\_line, from, COMMAND\_LINE\_SIZE);  
815  
816         /\* populate cmd\_line too for later use, preserving boot\_command\_line \*/  
817         strlcpy(cmd\_line, boot\_command\_line, COMMAND\_LINE\_SIZE);  
818         \*cmdline\_p = cmd\_line;  
819  
820         parse\_early\_param(); //解释命令行参数，见后  
821  
822         arm\_memblock\_init(&meminfo, mdesc);  
823  
824         paging\_init(mdesc);  
825         request\_standard\_resources(&meminfo, mdesc);//将设备实体登记注册到总线空间链表  
826  
827 \#ifdef CONFIG\_SMP  
828         smp\_init\_cpus();  
829 \#endif  
830         reserve\_crashkernel(); //要配置CONFIG\_KEXEC，否则为空函数,2410中没有配置  
831  
832         cpu\_init(); //对用到的IRQ, ABT, UND模式的SP都作了初始化  
833         tcm\_init(); //在ARM中是个空函数  
834  
835         /\* 根据arch/arm/mach-s3c2410/mach-smdk2410.c中 machine\_desc结构，   
               设置各种特定于体系结构的指针  
836          \* Set up various architecture-specific pointers  
837          \*/  
838         arch\_nr\_irqs = mdesc->nr\_irqs;  //在arch/arm/kernel/irq.c第171行，由nr\_irqs = arch\_nr\_irqs ? arch\_nr\_irqs : NR\_IRQS;引用，而nr\_irqs在init\_IRQ、asm\_do\_IRQ、set\_irq\_flags中都有引用  
  
839         init\_arch\_irq = mdesc->init\_irq; //在init\_IRQ函数第165行调用  
840         system\_timer = mdesc->timer;  
841         init\_machine = mdesc->init\_machine;  
842  
843 \#ifdef CONFIG\_VT  
844 \#if defined(CONFIG\_VGA\_CONSOLE)  
845         conswitchp = &vga\_con;  
846 \#elif defined(CONFIG\_DUMMY\_CONSOLE)  
847         conswitchp = &dummy\_con;  
848 \#endif  
849 \#endif  
850         early\_trap\_init(); //见后  
851 \}  
852  
  
769行tag数据结构在arch/arm/include/asm/setup.h中定义如下：  
struct tag \{  
    struct tag\_header hdr;  
    union \{  
        struct tag\_core        core;  
        struct tag\_mem32    mem;  
        struct tag\_videotext    videotext;  
        struct tag\_ramdisk    ramdisk;  
        struct tag\_initrd    initrd;  
        struct tag\_serialnr    serialnr;  
        struct tag\_revision    revision;  
        struct tag\_videolfb    videolfb;  
        struct tag\_cmdline    cmdline;  
  
        /\*  
         \* Acorn specific  
         \*/  
        struct tag\_acorn    acorn;  
  
        /\*  
         \* DC21285 specific  
         \*/  
        struct tag\_memclk    memclk;  
    \} u;  
\};  
其中init\_tags在arch/arm/kernel/setup.c文件下定义如下  
662 static struct init\_tags \{  
663         struct tag\_header hdr1;  
664         struct tag\_core   core;  
665         struct tag\_header hdr2;  
666         struct tag\_mem32  mem;  
667         struct tag\_header hdr3;  
668 \} init\_tags \_\_initdata = \{  
669         \{ tag\_size(tag\_core), ATAG\_CORE \},  
670         \{ 1, PAGE\_SIZE, 0xff \},  
671         \{ tag\_size(tag\_mem32), ATAG\_MEM \},  
672         \{ MEM\_SIZE, PHYS\_OFFSET \},  
673         \{ 0, ATAG\_NONE \}  
674 \};  
675  
676 static void (\*init\_machine)(void) \_\_initdata;  
770行完整的machine\_desc结构描述如下:arch/arm/include/asm/mach/arch.h  
 13 struct tag;  
 14 struct meminfo;  
 15 struct sys\_timer;  
 16  
 17 struct machine\_desc \{  
 18         /\*  
 19          \* Note! The first four elements are used  
 20          \* by assembler code in head.S, head-common.S  
 21          \*/  
 22         unsigned int            nr;             /\*  开发板的机器类型ID \*/  
 23         unsigned int            nr\_irqs;        /\* number of IRQs \*/  
 24         unsigned int            phys\_io;        /\*  起始IO物理地址 \*/  
 25         unsigned int            io\_pg\_offst;    /\* byte offset for io  
 26                                                  \* page tabe entry      \*/  
 27  
 28         const char              \*name;          /\*  开发板名称 \*/  
 29         unsigned long           boot\_params;    /\* tagged list 内核启动参数的地址\*/  
 30  
 31         unsigned int            video\_start;    /\* start of video RAM   \*/  
 32         unsigned int            video\_end;      /\* end of video RAM     \*/  
 33  
 34         unsigned int            reserve\_lp0 :1; /\* never has lp0        \*/  
 35         unsigned int            reserve\_lp1 :1; /\* never has lp1        \*/  
 36         unsigned int            reserve\_lp2 :1; /\* never has lp2        \*/  
 37         unsigned int            soft\_reboot :1; /\* soft reboot          \*/  
 38         void                    (\*fixup)(struct machine\_desc \*,  
 39                                          struct tag \*, char \*\*,  
 40                                          struct meminfo \*);  
 41         void                    (\*reserve)(void);/\* reserve mem blocks  \*/  
 42         void                    (\*map\_io)(void);/\* IO 映射函数（在这里修改时钟频率）\*/  
 43         void                    (\*init\_irq)(void);   /\*中断初始化函数\*/  
 44         struct sys\_timer        \*timer;         /\* system tick timer    \*/  
 45         void                    (\*init\_machine)(void);  
 46 \};  
  
771行default\_command\_line在setup.c文件129行中定义如下：  
static char default\_command\_line\[COMMAND\_LINE\_SIZE\] \_\_initdata = CONFIG\_CMDLINE;  
其中CONFIG\_CMDLINE在“.config”配置文件中定义的。  
773行arch/arm/kernel/unwind.c  
439 int \_\_init unwind\_init(void)  
440 \{  
441         struct unwind\_idx \*idx;  
442  
443         /\* Convert the symbol addresses to absolute values \*/  
444         for (idx = \_\_start\_unwind\_idx; idx < \_\_stop\_unwind\_idx; idx++)  
445                 idx->addr = prel31\_to\_addr(&idx->addr);  
446  
447         pr\_debug("unwind: ARM stack unwinding initialised\\n");  
448  
449         return 0;  
450 \}  
struct unwind\_idx \{  
    unsigned long addr;  
    unsigned long insn;  
\};  
776行，machine\_arch\_type在arch/arm/tools/gen-mach-types中第69行定义，  
printf("\#define machine\_arch\_type\\t\_\_machine\_arch\_type\\n")  
它最后会被转换成一个头文件include/generated/mach-types.h,包含在arch/arm/include/asm/mach- types.h文件中，\_\_machine\_arch\_type在arch/arm/kernel/head-common.S定义  
 27         .long   \_\_machine\_arch\_type             @ r5  
并通过arch/arm/kernel/head-common.S第60行命令  
 60         str     r1, \[r5\]                        @ Save machine type  
将bootloader通过r1传递过来的机器码保存到\_\_machine\_arch\_type。  
   下面我们来看setup\_machine函数，在在arch/arm/kernel/setup.c文件下定义如下  
391 static struct machine\_desc \* \_\_init setup\_machine(unsigned int nr)  
392 \{  
393         struct machine\_desc \*list;  
394  
395         /\*  
396          \* locate machine in the list of supported machines.  
397          \*/  
398         list = lookup\_machine\_type(nr);  
399         if (!list) \{  
400                 printk("Machine configuration botched (nr %d), unable "  
401                        "to continue.\\n", nr);  
402                 while (1);  
403         \}  
404  
405         printk("Machine: %s\\n", list->name);  
406  
407         return list;  
408 \}  
在这个函数中就是查找你是什么版本的处理器架构，最后就是调用了lookup\_processor\_type这个函数，它在汇编部分也提到过，在arch/arm/kernel/head-common.S定义  
230 ENTRY(lookup\_machine\_type)  
231         stmfd   sp!, \{r4 - r6, lr\}  
232         mov     r1, r0  
233         bl      \_\_lookup\_machine\_type  
234         mov     r0, r5  
235         ldmfd   sp!, \{r4 - r6, pc\}  
236 ENDPROC(lookup\_machine\_type)  
可见最后调用的是\_\_lookup\_machine\_type，这个函数在汇编中我们已经分析过了。这里再来分析一下：  
内核中对于每种支持的开发板都会使用宏MACHINE\_START、MACHINE\_END来定义一个machine\_desc结构，它定义开发板相关的一些属性及函数，比如机器类型ID、起始I/O物理地址、Bootloader传入的参数的地址、中断初始化函数、I/O映射函数等，比如对于 SMDK2410开发板，在arch/arm/mach-s3c2410/mach-smdk2410.c中定义如下：  
MACHINE\_START(SMDK2410, "SMDK2410") /\* @TODO: request a new identifier and switch  
                                    \* to SMDK2410 \*/  
        /\* Maintainer: Jonas Dietsche \*/  
        .phys\_io        = S3C2410\_PA\_UART,  
        .io\_pg\_offst    = (((u32)S3C24XX\_VA\_UART) >> 18) & 0xfffc,  
        .boot\_params    = S3C2410\_SDRAM\_PA + 0x100,  
        .map\_io         = smdk2410\_map\_io,  
        .init\_irq       = s3c24xx\_init\_irq,  
        .init\_machine   = smdk2410\_init,  
        .timer          = &s3c24xx\_timer,  
MACHINE\_END  
而宏MACHINE\_START、MACHINE\_END在arch/arm/include/asm/mach/arch.h中定义如下：  
 52 \#define MACHINE\_START(\_type,\_name)                      \\  
 53 static const struct machine\_desc \_\_mach\_desc\_\#\#\_type    \\  
 54  \_\_used                                                 \\  
 55  \_\_attribute\_\_((\_\_section\_\_(".arch.info.init"))) = \{    \\  
 56         .nr             = MACH\_TYPE\_\#\#\_type,            \\  
 57         .name           = \_name,  
 58  
 59 \#define MACHINE\_END                             \\  
 60 \};  
所以以下展开后如下：  
static const struct machine\_desc \_\_mach\_desc\_SMDK2410  
  \_\_used                                                  
  \_\_attribute\_\_((\_\_section\_\_(".arch.info.init"))) = \{     
        .nr             = MACH\_TYPE\_SMDK2410,             
        .name           = SMDK2410,  
        .phys\_io        = S3C2410\_PA\_UART,  
        .io\_pg\_offst    = (((u32)S3C24XX\_VA\_UART) >> 18) & 0xfffc,  
        .boot\_params    = S3C2410\_SDRAM\_PA + 0x100,  
        .map\_io         = smdk2410\_map\_io,  
        .init\_irq       = s3c24xx\_init\_irq,  
        .init\_machine   = smdk2410\_init,  
        .timer          = &s3c24xx\_timer,  
\};  
对照前面完整的machine\_desc结构描述就能找到系统定义开发板相关的一些属性及函数  
 所有machine\_desc结构体初始化后被编译连接到“.arch.info.init”段中，在连接内核时，它们被组织在一起，开始地址为 \_\_arch\_info\_begin，结束地址为\_\_arch\_info\_end，从连接脚本“arch/arm/kernel /vmlinux.lds.S”中可以看出：  
 37                 \_\_arch\_info\_begin = .;    //machine\_desc结构体的开始地址  
 38                         \*(.arch.info.init)  //所有machine\_desc都在这里面  
 39                 \_\_arch\_info\_end = .;     //machine\_desc结构体的开始地址  
不同的machine\_desc结构用于不同的开发板，U-BOOT调用内核时，会在r1寄存器中给出开发板的标记(机器类型ID)；对于S3C2410、 S3C2440开发板，U-Boot传入的机器类型ID为MACH\_TYPE\_SMDK2410、MACH\_TYPE\_S3C2440，它们对应的 machine\_desc结构分别在arch/arm/mach-s3c2410/mach-smdk2410.c和  
arch/arm/mach-s3c2440/mach-smdk2440.c中定义，现在再来看看\_\_lookup\_machine\_type函数。它在arch/arm/kernel/head-common.S中定义如下：  
196 4:      .long   .          //当前行编译链接后的虚拟地址  
197         .long   \_\_arch\_info\_begin   //machine\_desc结构体的开始地址(虚拟地址)  
198         .long   \_\_arch\_info\_end     //machine\_desc结构体的结束地址(虚拟地址)  
  
211 \_\_lookup\_machine\_type:  
212         adr     r3, 4b        //r3 = 196行的物理地址  
213         ldmia   r3, \{r4, r5, r6\} /\*\[r3\]->r4,\[r3+4\]->r5,\[r3+8\]->r6,  
                                    r4 = 196行的虚拟地址,  
                                    r5 = \_\_arch\_info\_begin (VA)  
                                    r6 = \_\_arch\_info\_end (VA)\*/  
214         sub     r3, r3, r4 @r3=(196行的物理地址)-(196行的虚拟地址),即物理地址与虚拟地址的差值  
215         add     r5, r5, r3  @  r5= \_\_arch\_info\_begin(物理地址)，虚拟地址转物理地址  
216         add     r6, r6, r3  @ r6= \_\_arch\_info\_end(物理地址)  
217 1:      ldr     r3, \[r5, \#MACHINFO\_TYPE\]        @ r5是machine\_desc结构体地址  
218         teq     r3, r1    @ matches loader number? r1是Bootloader调用内核时传入的机器类型ID  
219         beq     2f                              @ found  相等则跳转到224行  
220         add     r5, r5, \#SIZEOF\_MACHINE\_DESC    @ 否则跳转到下一个machine\_desc结构体  
 其中MACHINFO\_TYPE，SIZEOF\_MACHINE\_DESC 在arch/arm/kernel/asm-offsets.c中定义：  
 DEFINE(MACHINFO\_TYPE,        offsetof(struct machine\_desc, nr));  
 DEFINE(SIZEOF\_MACHINE\_DESC,    sizeof(struct machine\_desc));  
offsetof在include/linux/stddef.h中定义：  
\#define offsetof(TYPE, MEMBER) ((size\_t) &((TYPE \*)0)->MEMBER)  
可以看出nr是函数setup\_machine传递过来的参数，这里得到的是machine\_desc结构体地址。  
221         cmp     r5, r6    是否已经比较完所有的machine\_desc结构体  
222         blo     1b        没有则继续比较（lo:无符号小于）  
223         mov     r5, \#0       @ 比较完毕，但没有匹配的machine\_desc结构体，r5=0  
224 2:      mov     pc, lr    返回  
225 ENDPROC(\_\_lookup\_machine\_type)  
上面代码功能说明：  
\_\_lookup\_machine\_type 函数将这个r1寄存器中的机器类型ID与“.arch.info.init”段中machine\_desc结构中的nr成员比较，如果相等则表示找到了匹配的machine\_desc结构，于是返回它的地址(存于r5中)，如果\_\_arch\_machine\_begin和 \_\_arch\_machine\_end间所有machine\_desc结构的nr成员都不等于r1寄存器中的值，则返回0(r5等于0)  
  
在配置菜单时，选中两个开发板即可：  
    System Type--->  
         S3C2410 Machines--->  
              \[\*\] SMDK2410/A9M2410  
         S3C2440 Machines--->  
              \[\*\] SMDK2440  
第780行reboot\_setup函数在arch/arm/kernel/process.c定义如下：  
198 static char reboot\_mode = 'h';  
199  
200 int \_\_init reboot\_setup(char \*str)  
201 \{  
202         reboot\_mode = str\[0\];  
203         return 1;  
204 \}  
205  
206 \_\_setup("reboot=", reboot\_setup);  
reboot这个参数在引导参数中设置。  
第782行\_\_atags\_pointer是bootloader传递参数的物理地址,见第一阶段启动源码arch/arm/kernel/head-common.S第61行(str r2, \[r6\]),此处r6就是\_\_atags\_pointer的地址，\_\_atags\_pointer在28处有定义，它将bootloader通过r2传递过来的地址参数存放到 \_\_atags\_pointer。  
第783、784行，由于MMU单元已打开，此处\_\_atags\_pointer是物理地址，需要转换成虚拟地址才能访问，因为此时CPU访问的都是虚拟地址，在这里如果bootloader没有传递地址参数则就使用arch/arm/mach-s3c2410 /mach-smdk2410.c文件中MACHINE\_START、MACHINE\_END定义的boot\_params参数，对2410定义如下：  
.boot\_params    = S3C2410\_SDRAM\_PA + 0x100,  
S3C2410\_SDRAM\_PA在arch/arm/mach-s3c2410/include/mach/map.h中定义如下  
\#define S3C2410\_CS6 (0x30000000)  
\#define S3C2410\_CS7 (0x38000000)  
\#define S3C2410\_SDRAM\_PA    (S3C2410\_CS6)  
所以.boot\_params参数地址是0x30000100位置  
801         if (tags->hdr.tag == ATAG\_CORE) \{  
802                 if (meminfo.nr\_banks != 0) //说明内存被初始化过  
803                         squash\_mem\_tags(tags);//如果是tag list,那么如果系统已经创建了默认的meminfo.nr\_banks，清除tags中关于MEM的参数，以免再次被初始化  
804                 save\_atags(tags);  
805                 parse\_tags(tags);//做出一些针对各个tags的处理  
806         \}  
803行squash\_mem\_tags定义如下（arch/arm/kernel/setup.c)  
static void \_\_init squash\_mem\_tags(struct tag \*tag)  
\{  
    for (; tag->hdr.size; tag = tag\_next(tag))  
        if (tag->hdr.tag == ATAG\_MEM)  
            tag->hdr.tag = ATAG\_NONE;  
\}  
这个函数功能是清除tags中关于MEM的参数，以免再次被初始化  
804行save\_atags定义如下（arch/arm/kernel/atags.c)  
\#define BOOT\_PARAMS\_SIZE 1536  
static char \_\_initdata atags\_copy\[BOOT\_PARAMS\_SIZE\];  
  
void \_\_init save\_atags(const struct tag \*tags)  
\{  
    memcpy(atags\_copy, tags, sizeof(atags\_copy));  
\}  
805行parse\_tags定义如下（arch/arm/kernel/setup.c)  
static void \_\_init parse\_tags(const struct tag \*t)  
\{  
    for (; t->hdr.size; t = tag\_next(t))  
        if (!parse\_tag(t)) //针对每个tag 调用parse\_tag 函数  
            printk(KERN\_WARNING  
                "Ignoring unrecognised tag 0x%08x\\n",  
                t->hdr.tag);  
\}  
这个函数解析内核参数列表，然后调用内核参数列表的处理函数对这些参数进行处理。比如，如果列表为命令行，则最终会用parse\_tag\_cmdlin函数进行解析，这个函数用\_tagtable编译连接到了内核里，其中如果U-boot传入ATAG\_CMDLINE，则使用U-boot传入的 bootargs覆盖default\_command\_line  
static int \_\_init parse\_tag(const struct tag \*tag)  
\{  
    extern struct tagtable \_\_tagtable\_begin, \_\_tagtable\_end;  
    struct tagtable \*t;  
  
    for (t = &\_\_tagtable\_begin; t < &\_\_tagtable\_end; t++) //遍历tagtable列表，并调用处理函数，  
        if (tag->hdr.tag == t->tag) \{  
            t->parse(tag);  
            break;  
        \}  
  
    return t < &\_\_tagtable\_end;  
\}  
arch/arm/include/asm/setup.h  
struct tagtable \{  
    \_\_u32 tag;  
    int (\*parse)(const struct tag \*);  
\};  
\#define tag\_next(t)    ((struct tag \*)((\_\_u32 \*)(t) + (t)->hdr.size))  
\#define tag\_size(type)    ((sizeof(struct tag\_header) + sizeof(struct type)) >> 2)  
  
\#define for\_each\_tag(t,base)        \\  
    for (t = base; t->hdr.size; t = tag\_next(t))  
  
\#ifdef \_\_KERNEL\_\_  
  
\#define \_\_tag \_\_used \_\_attribute\_\_((\_\_section\_\_(".taglist.init")))  
\#define \_\_tagtable(tag, fn) \\  
static struct tagtable \_\_tagtable\_\#\#fn \_\_tag = \{ tag, fn \}  
这个tagtable 列表 是怎么形成的？  
如arch/arm/kernel/setup.c  
556 static int \_\_init parse\_tag\_mem32(const struct tag \*tag)  
557 \{  
558         return arm\_add\_memory(tag->u.mem.start, tag->u.mem.size);  
559 \}  
560  
561 \_\_tagtable(ATAG\_MEM, parse\_tag\_mem32);  
  
607 \_\_tagtable(ATAG\_SERIAL, parse\_tag\_serialnr);  
608  
609 static int \_\_init parse\_tag\_revision(const struct tag \*tag)  
610 \{  
611         system\_rev = tag->u.revision.rev;  
612         return 0;  
613 \}  
614  
615 \_\_tagtable(ATAG\_REVISION, parse\_tag\_revision);  
  
618 static int \_\_init parse\_tag\_cmdline(const struct tag \*tag)  
619 \{  
620         strlcpy(default\_command\_line, tag->u.cmdline.cmdline, COMMAND\_LINE\_SIZE);  
621         return 0;  
622 \}  
623  
624 \_\_tagtable(ATAG\_CMDLINE, parse\_tag\_cmdline);  
根据前面相关宏定义，\_\_tagtable(ATAG\_CMDLINE, parse\_tag\_cmdline)展开后为  
static struct tagtable \_\_tagtable\_parse\_tag\_cmdline \_\_used \_\_attribute\_\_((\_\_section\_\_(".taglist.init"))) = \{ ATAG\_CMDLINE, parse\_tag\_cmdline ｝  
再参看arch/arm/kernel/vmlinux.lds.S文件  
 34                 \_\_proc\_info\_begin = .;  
 35                         \*(.proc.info.init)  
 36                 \_\_proc\_info\_end = .;  
 37                 \_\_arch\_info\_begin = .;  
 38                         \*(.arch.info.init)  
 39                 \_\_arch\_info\_end = .;  
 40                 \_\_tagtable\_begin = .;  
 41                         \*(.taglist.init)  
 42                 \_\_tagtable\_end = .;  
tagtable 列表编译连接后被存放在.taglist.init中。  
  
从808行到811行是init\_mm的初始化，记录内核代码的起始，结束虚拟地址  
808         init\_mm.start\_code = (unsigned long) \_text;  内核代码段开始  
809         init\_mm.end\_code   = (unsigned long) \_etext; 内核代码段结束  
810         init\_mm.end\_data   = (unsigned long) \_edata; 内核数据段开始  
811         init\_mm.brk        = (unsigned long) \_end;  内核数据段结束  
 \_text,\_etext,\_edata,\_end参见arch/arm/kernel/vmlinux.lds.S 链接脚本,init\_mm定义在mm/init-mm.c  
 12 \#ifndef INIT\_MM\_CONTEXT  
 13 \#define INIT\_MM\_CONTEXT(name)  
 14 \#endif  
 15  
 16 struct mm\_struct init\_mm = \{  
 17         .mm\_rb          = RB\_ROOT,  
 18         .pgd            = swapper\_pg\_dir,  
 19         .mm\_users       = ATOMIC\_INIT(2),  
 20         .mm\_count       = ATOMIC\_INIT(1),  
 21         .mmap\_sem       = \_\_RWSEM\_INITIALIZER(init\_mm.mmap\_sem),  
 22         .page\_table\_lock =  \_\_SPIN\_LOCK\_UNLOCKED(init\_mm.page\_table\_lock),  
 23         .mmlist         = LIST\_HEAD\_INIT(init\_mm.mmlist),  
 24         .cpu\_vm\_mask    = CPU\_MASK\_ALL,  
 25         INIT\_MM\_CONTEXT(init\_mm)  
 26 \};  
  
每一个任务都有一个mm\_struct结构管理任务内存空间，init\_mm是内核的mm\_struct，设置\* pgd=swapper\_pg\_dir，swapper\_pg\_dir是内核的页目录，在arm体系结构有16k，所以init\_mm定义了整个 kernel的内存空间，下面我们会碰到内核线程，所有的内核线程都使用内核空间，拥有和内核同样的访问权限。对于内存管理后面再做详细分析。  
mm\_struct结构定义在include/linux/mm\_types.h中，  
struct mm\_struct \{  
    struct vm\_area\_struct \* mmap;        /\* list of VMAs \*/  
    struct rb\_root mm\_rb;  
    struct vm\_area\_struct \* mmap\_cache;    /\* last find\_vma result \*/  
\#ifdef CONFIG\_MMU  
    unsigned long (\*get\_unmapped\_area) (struct file \*filp,  
                unsigned long addr, unsigned long len,  
                unsigned long pgoff, unsigned long flags);  
    void (\*unmap\_area) (struct mm\_struct \*mm, unsigned long addr);  
\#endif  
    unsigned long mmap\_base;        /\* base of mmap area \*/  
    unsigned long task\_size;        /\* size of task vm space \*/  
    unsigned long cached\_hole\_size;     /\* if non-zero, the largest hole below free\_area\_cache \*/  
    unsigned long free\_area\_cache;        /\* first hole of size cached\_hole\_size or larger \*/  
    pgd\_t \* pgd;  
    atomic\_t mm\_users;            /\* How many users with user space? \*/  
    atomic\_t mm\_count;            /\* How many references to "struct mm\_struct" (users count as 1) \*/  
    int map\_count;                /\* number of VMAs \*/  
    struct rw\_semaphore mmap\_sem;  
    spinlock\_t page\_table\_lock;        /\* Protects page tables and some counters \*/  
  
    struct list\_head mmlist;        /\* List of maybe swapped mm's.    These are globally strung  
                         \* together off init\_mm.mmlist, and are protected  
                         \* by mmlist\_lock  
                         \*/  
  
  
    unsigned long hiwater\_rss;    /\* High-watermark of RSS usage \*/  
    unsigned long hiwater\_vm;    /\* High-water virtual memory usage \*/  
  
    unsigned long total\_vm, locked\_vm, shared\_vm, exec\_vm;  
    unsigned long stack\_vm, reserved\_vm, def\_flags, nr\_ptes;  
    unsigned long start\_code, end\_code, start\_data, end\_data;  
    unsigned long start\_brk, brk, start\_stack;  
    unsigned long arg\_start, arg\_end, env\_start, env\_end;  
  
    unsigned long saved\_auxv\[AT\_VECTOR\_SIZE\]; /\* for /proc/PID/auxv \*/  
  
    /\*  
     \* Special counters, in some configurations protected by the  
     \* page\_table\_lock, in other configurations by being atomic.  
     \*/  
    struct mm\_rss\_stat rss\_stat;  
  
    struct linux\_binfmt \*binfmt;  
  
    cpumask\_t cpu\_vm\_mask;  
  
    /\* Architecture-specific MM context \*/  
    mm\_context\_t context;  
  
    /\* Swap token stuff \*/  
    /\*  
     \* Last value of global fault stamp as seen by this process.  
     \* In other words, this value gives an indication of how long  
     \* it has been since this task got the token.  
     \* Look at mm/thrash.c  
     \*/  
    unsigned int faultstamp;  
    unsigned int token\_priority;  
    unsigned int last\_interval;  
  
    unsigned long flags; /\* Must use atomic bitops to access the bits \*/  
  
    struct core\_state \*core\_state; /\* coredumping support \*/  
\#ifdef CONFIG\_AIO  
    spinlock\_t        ioctx\_lock;  
    struct hlist\_head    ioctx\_list;  
\#endif  
\#ifdef CONFIG\_MM\_OWNER  
    /\*  
     \* "owner" points to a task that is regarded as the canonical  
     \* user/owner of this mm. All of the following must be true in  
     \* order for it to be changed:  
     \*  
     \* current == mm->owner  
     \* current->mm != mm  
     \* new\_owner->mm == mm  
     \* new\_owner->alloc\_lock is held  
     \*/  
    struct task\_struct \*owner;  
\#endif  
  
\#ifdef CONFIG\_PROC\_FS  
    /\* store ref to file /proc/<pid>/exe symlink points to \*/  
    struct file \*exe\_file;  
    unsigned long num\_exe\_file\_vmas;  
\#endif  
\#ifdef CONFIG\_MMU\_NOTIFIER  
    struct mmu\_notifier\_mm \*mmu\_notifier\_mm;  
\#endif  
\};  
  
第814行，下面是对命令行的处理，刚才在参数列表处理parse\_tag\_cmdline函数已把命令行拷贝到了from空间（from前面定义成了default\_command\_line），这里814行是把命令行拷贝到boot\_command\_line，boot\_command\_line在后面的parse\_early\_param为用到，boot\_command\_line在init/main.c中定义  
char \_\_initdata boot\_command\_line\[COMMAND\_LINE\_SIZE\];指定变量存放在\_\_initdata区  
第817行， 填充cmd\_line，以备以后使用，维护boot\_command\_line， cmd\_line在 127行定义  
static char \_\_initdata cmd\_line\[COMMAND\_LINE\_SIZE\];指定变量存放在\_\_initdata区  
\_\_initdata在前面的分析中出现了好几次， 在这里我们来对它详细分析  
Linux在arch/arm/kernel/vmlinux.lds.S中定义了.init段。\_\_init和\_\_initdata属性的数据都在这个段中，当内核启动完毕后，这个段中的内存会被释放掉供其他使用。  
\_\_init和\_\_initdata宏定义如下(include/linux/init.h)：  
\#define \_\_init          \_\_section(.init.text) \_\_cold notrace  
\#define \_\_initdata      \_\_section(.init.data)  
vmlinux.lds.S有如下内容：  
/\* arch/arm/kernel/vmlinux.lds.S\*/  
 20 SECTIONS  
 21 \{  
 22 \#ifdef CONFIG\_XIP\_KERNEL  
 23         . = XIP\_VIRT\_ADDR(CONFIG\_XIP\_PHYS\_ADDR);  
 24 \#else  
 25         . = PAGE\_OFFSET + TEXT\_OFFSET;  
 26 \#endif  
 27  
 28         .init : \{                       /\* Init code and data           \*/  
 29                 \_stext = .;  
 30                 \_sinittext = .;  
 31                         HEAD\_TEXT  
 32                         INIT\_TEXT  
 33                 \_einittext = .;  
 34                 \_\_proc\_info\_begin = .;  
 35                         \*(.proc.info.init)  
 36                 \_\_proc\_info\_end = .;  
 37                 \_\_arch\_info\_begin = .;  
 38                         \*(.arch.info.init)  
 39                 \_\_arch\_info\_end = .;  
 40                 \_\_tagtable\_begin = .;  
 41                         \*(.taglist.init)  
 42                 \_\_tagtable\_end = .;  
 43  
 44                 INIT\_SETUP(16)  
 45  
 46                 INIT\_CALLS  
 47                 CON\_INITCALL  
 48                 SECURITY\_INITCALL  
 49                 INIT\_RAM\_FS  
 50  
 51 \#ifndef CONFIG\_XIP\_KERNEL  
 52                 \_\_init\_begin = \_stext;  
 53                 INIT\_DATA  
 54 \#endif  
 55         \}  
  
第32的INIT\_TEXT和第53行INIT\_DATA在include/asm-generic/vmlinux.lds.h定义如下  
457 /\* init and exit section handling \*/  
458 \#define INIT\_DATA                                                       \\  
459         \*(.init.data)                                                   \\  
460         DEV\_DISCARD(init.data)                                          \\  
461         CPU\_DISCARD(init.data)                                          \\  
462         MEM\_DISCARD(init.data)                                          \\  
463         KERNEL\_CTORS()                                                  \\  
464         \*(.init.rodata)                                                 \\  
465         MCOUNT\_REC()                                                    \\  
466         DEV\_DISCARD(init.rodata)                                        \\  
467         CPU\_DISCARD(init.rodata)                                        \\  
468         MEM\_DISCARD(init.rodata)  
469  
470 \#define INIT\_TEXT                                                       \\  
471         \*(.init.text)                                                   \\  
472         DEV\_DISCARD(init.text)                                          \\  
473         CPU\_DISCARD(init.text)                                          \\  
474         MEM\_DISCARD(init.text)  
475  
可以发现\_\_init对应的section(.init.text)和\_\_initdata对应的section(.init.data)都在.init 段中。同样,这里定义的其他一些section也都会在使用完后被释放，如.init.setup，.initcall1.init等。  
释放memory的大小会在系统启动过程中打印出来：  
eth0: link up  
IP-Config: Complete:  
device=eth0, addr=192.168.167.15, mask=255.255.255.0, gw=192.168.1.1,  
host=192.168.167.15, domain=, nis-domain=(none),  
bootserver=192.168.1.8, rootserver=192.168.1.54, rootpath=  
Looking up port of RPC 100003/2 on 192.168.167.170  
Looking up port of RPC 100005/1 on 192.168.167.170  
VFS: Mounted root (nfs filesystem).  
Freeing init memory: 128K  
  
在分析820行的parse\_early\_param函数前，先说一下系统启动时对bootloader传递参数的初始化，即linux启动参数的实现，启动参数的实现，我们知道boot传递给内核的参数都是 "name\_varibale=value"这种形式的，如下：  
CONFIG\_CMDLINE="root=/dev/mtdblock3 init=/linuxrc console=ttySAC0,115200 mem=64M"  
那么内核如何知道传递进来的参数该怎么去处理呢？  
内核是通过\_\_setup宏或者early\_param宏来将参数与参数所处理的函数相关联起来的。我们接下来就来看这个宏以及相关的结构的定义：  
include/linux/init.h  
230 \#define \_\_setup\_param(str, unique\_id, fn, early)                        \\  
231         static const char \_\_setup\_str\_\#\#unique\_id\[\] \_\_initconst \\  
232                 \_\_aligned(1) = str; \\  
233         static struct obs\_kernel\_param \_\_setup\_\#\#unique\_id      \\  
234                 \_\_used \_\_section(.init.setup)                   \\  
235                 \_\_attribute\_\_((aligned((sizeof(long)))))        \\  
236                 = \{ \_\_setup\_str\_\#\#unique\_id, fn, early \}  
237  
238 \#define \_\_setup(str, fn)                                        \\  
239         \_\_setup\_param(str, fn, fn, 0)  
240  
241 /\* NOTE: fn is as per module\_param, not \_\_setup!  Emits warning if fn  
242  \* returns non-zero. \*/  
243 \#define early\_param(str, fn)                                    \\  
244         \_\_setup\_param(str, fn, fn, 1)  
看起来很复杂。 首先setup宏第一个参数是一个key。比如"netdev="这样的，而第二个参数是这个key对应的处理函数。这里要注意相同的handler能联系到不同的key。\_\_setup与early\_param不同的是，early\_param宏注册的内核选项必须要在其他内核选项之前被处理。在函数start\_kernel中，parse\_early\_param处理early\_param定义的参数，parse\_args处理\_\_setup定义的参数。  
early\_param和setup唯一不同的就是传递给\_\_setup\_param的最后一个参数，这个参数下面会说明，而接下来\_setup\_param定义了一个struct obs\_kernel\_param类型的结构，然后通过\_section宏，使这个变量在链接的时候能够放置在段.init.setup(后面会详细介绍内核中的这些初始化段).  
  
接下来来看struct obs\_kernel\_param结构：  
include/linux/init.h  
218 struct obs\_kernel\_param \{  
219         const char \*str;  
220         int (\*setup\_func)(char \*);  
221         int early;  
222 \};  
  
前两个参数很简单，一个是key，一个是handler。最后一个参数其实也就是类似于优先级的一个flag，因为传递给内核的参数中，有一些需要比另外的一些更早的解析。(这也就是为什么early\_param和setup传递的最后一个参数的不同的原因了。  
启动参数的实现  
1,所有的系统启动参数都是由形如  
static int \_\_init init\_setup(char \*str)  
的函数来支持的  
init/main.c  
static int \_\_init init\_setup(char \*str)  
\{  
    unsigned int i;  
  
    execute\_command = str;  
    for (i = 1; i < MAX\_INIT\_ARGS; i++)  
        argv\_init\[i\] = NULL;  
    return 1;  
\}  
\_\_setup("init=", init\_setup);  
注：(include/linux/init.h)：  
\#define \_\_init          \_\_section(.init.text) \_\_cold notrace申明所有的启动参数支持函数都放入.init.text段  
2.1,用\_\_setup宏来导出参数的支持函数  
\_\_setup("init=", init\_setup);  
展开后就是如下的形式  
  
static const char \_\_setup\_str\_init\_setup\[\] \_\_initdata = "init=";    
static struct obs\_kernel\_param \_\_setup\_init\_setup                
        \_\_used \_\_section\_\_(".init.setup")  
        \_\_attribute\_\_((aligned((sizeof(long)))))    
        = \{ \_\_setup\_str\_init\_setup, init\_setup, 0 \};//"init=",init\_setup,0  
也就是说,启动参数(函数指针)被封装到obs\_kernel\_param结构中,  
所有的内核启动参数形成内核映像.init.setup段中的一个  
obs\_kernel\_param数组  
  
2.2用early\_param宏来申明需要'早期'处理的启动参数,例如在  
arch/arm/kernel/setup.c就有如下的申明:  
468 early\_param("mem", early\_mem);  
展开后和\_\_setup是一样的只是early参数不一样,因此会在do\_early\_param  
中被处理  
443 static int \_\_init early\_mem(char \*p)  
444 \{  
445         static int usermem \_\_initdata = 0;  
446         unsigned long size, start;  
447         char \*endp;  
448  
449         /\*  
453          \*/  
454         if (usermem == 0) \{  
455                 usermem = 1;  
456                 meminfo.nr\_banks = 0;  
457         \}  
458  
459         start = PHYS\_OFFSET;  
460         size  = memparse(p, &endp);  
461         if (\*endp == '@')  
462                 start = memparse(endp + 1, NULL);  
463  
464         arm\_add\_memory(start, size);  
465  
466         return 0;  
467 \}  
  
3,内核对启动参数的解析:下面函数历遍obs\_kernel\_param数组,调用  
支持函数  
static int \_\_init do\_early\_param(char \*param, char \*val)  
这个函数在parse\_early\_param中被调用,而parse\_early\_param在start\_kernel  
中被调用,parse\_early\_param之后的parse\_args会调用下面函数  
static int \_\_init obsolete\_checksetup(char \*line)  
这两个函数后面会讲到。  
init/main.c中启动参数申明列表:  
early\_param("nosmp", nosmp);  
early\_param("nr\_cpus", nrcpus);  
early\_param("maxcpus", maxcpus);  
\_\_setup("reset\_devices", set\_reset\_devices);  
early\_param("debug", debug\_kernel);  
early\_param("quiet", quiet\_kernel);  
early\_param("loglevel", loglevel);  
\_\_setup("init=", init\_setup);  
\_\_setup("rdinit=", rdinit\_setup);  
arch/arm/kernel/setup.c中启动参数申明列表:  
\_\_setup("fpe=", fpe\_setup);  
early\_param("mem", early\_mem);  
early\_param("elfcorehdr", setup\_elfcorehdr);  
  
接下来我们来看内核解析bootloader传递给内核的参数的步骤：  
先看下面的图：  
[![21455R2b-1.jpg][]][21455R2b-1.jpg]  
可以看到内核首先通过parse\_early\_param来解析优先级更高的，也就是需要被更早解析的命令行参数，然后通过parse\_ares来解析一般的命令行参数.  
现在再来看看start\_arch函数中第820行的parse\_early\_param函数  
init/main.c  
void \_\_init parse\_early\_options(char \*cmdline)  
\{  
    parse\_args("early options", cmdline, NULL, 0, do\_early\_param);  
\}  
  
/\* Arch code calls this early on, or if not, just before other parsing. \*/  
void \_\_init parse\_early\_param(void)  
\{  
    static \_\_initdata int done = 0;  
    static \_\_initdata char tmp\_cmdline\[COMMAND\_LINE\_SIZE\];  
  
    if (done)  
        return;  
  
    /\* All fall through to do\_early\_param. \*/  
    strlcpy(tmp\_cmdline, boot\_command\_line, COMMAND\_LINE\_SIZE);  
    parse\_early\_options(tmp\_cmdline);  
    done = 1;  
\}  
在上面我们可以看到最终调用的是 parse\_args("early options", cmdline, NULL, 0, do\_early\_param);它调用do\_early\_param函数处理early\_param定义的参数函数  
这个函数还另一种调用形式  
parse\_args("Booting kernel", static\_command\_line, \_\_start\_\_\_param,\_stop\_\_\_param - \_\_start\_\_\_param,&unknown\_bootoption); 它调用unknown\_bootoption函数处理\_\_setup定义的参数，unknown\_bootoption函数在init/main.c中定义如下：  
static int \_\_init unknown\_bootoption(char \*param, char \*val)  
\{  
    /\* Change NUL term back to "=", to make "param" the whole string. \*/  
    if (val) \{  
        /\* param=val or param="val"? \*/  
        if (val == param+strlen(param)+1)  
            val\[-1\] = '=';  
        else if (val == param+strlen(param)+2) \{  
            val\[-2\] = '=';  
            memmove(val-1, val, strlen(val)+1);  
            val--;  
        \} else  
            BUG();  
    \}  
  
    /\* Handle obsolete-style parameters \*/  
    if (obsolete\_checksetup(param))  
        return 0;  
  
    /\* Unused module parameter. \*/  
    if (strchr(param, '.') && (!val || strchr(param, '.') < val))  
        return 0;  
  
    if (panic\_later)  
        return 0;  
  
    if (val) \{  
        /\* Environment option \*/  
        unsigned int i;  
        for (i = 0; envp\_init\[i\]; i++) \{  
            if (i == MAX\_INIT\_ENVS) \{  
                panic\_later = "Too many boot env vars at \`%s'";  
                panic\_param = param;  
            \}  
            if (!strncmp(param, envp\_init\[i\], val - param))  
                break;  
        \}  
        envp\_init\[i\] = param;  
    \} else \{  
        /\* Command line option \*/  
        unsigned int i;  
        for (i = 0; argv\_init\[i\]; i++) \{  
            if (i == MAX\_INIT\_ARGS) \{  
                panic\_later = "Too many boot init vars at \`%s'";  
                panic\_param = param;  
            \}  
        \}  
        argv\_init\[i\] = param;  
    \}  
    return 0;  
\}  
在这个函数中它调用了obsolete\_checksetup函数，该函数也定义在init/main.c中  
static int \_\_init obsolete\_checksetup(char \*line)  
\{  
    const struct obs\_kernel\_param \*p;  
    int had\_early\_param = 0;  
  
    p = \_\_setup\_start;  
    do \{  
        int n = strlen(p->str);  
        if (!strncmp(line, p->str, n)) \{  
            if (p->early) \{  
                /\* Already done in parse\_early\_param?  
                 \* (Needs exact match on param part).  
                 \* Keep iterating, as we can have early  
                 \* params and \_\_setups of same names 8( \*/  
                if (line\[n\] == '\\0' || line\[n\] == '=')  
                    had\_early\_param = 1;  
            \} else if (!p->setup\_func) \{  
                printk(KERN\_WARNING "Parameter %s is obsolete,"  
                       " ignored\\n", p->str);  
                return 1;  
            \} else if (p->setup\_func(line + n)) //调用支持函数  
                return 1;  
        \}  
        p++;  
    \} while (p < \_\_setup\_end);  
  
    return had\_early\_param;  
\}  
我们再来看一下do\_early\_param函数，它在init/main.c中  
static int \_\_init do\_early\_param(char \*param, char \*val)  
\{  
    const struct obs\_kernel\_param \*p;  
    这里的\_\_setup\_start和\_-setup\_end分别是.init.setup段的起始和结束的地址  
    for (p = \_\_setup\_start; p < \_\_setup\_end; p++) \{ 如果没有early标志则跳过  
        if ((p->early && strcmp(param, p->str) == 0) ||  
            (strcmp(param, "console") == 0 &&  
             strcmp(p->str, "earlycon") == 0)  
        ) \{    
            if (p->setup\_func(val) != 0)  调用处理函数  
                printk(KERN\_WARNING  
                       "Malformed early option '%s'\\n", param);  
        \}  
    \}  
    /\* We accept everything at this stage. \*/  
    return 0;  
\}  
parse\_args在kernel/params.c中定义，注意它与前面讲到的parse\_args区别。  
/\* Args looks like "foo=bar,bar2 baz=fuz wiz". \*/  
int parse\_args(const char \*name,  
           char \*args,  
           const struct kernel\_param \*params,  
           unsigned num,  
           int (\*unknown)(char \*param, char \*val))  
\{  
    char \*param, \*val;  
  
    DEBUGP("Parsing ARGS: %s\\n", args);  
  
    /\* Chew leading spaces \*/  
    args = skip\_spaces(args);  
  
    while (\*args) \{  
        int ret;  
        int irq\_was\_disabled;  
  
        args = next\_arg(args, &param, &val);  
        irq\_was\_disabled = irqs\_disabled();  
        ret = parse\_one(param, val, params, num, unknown);  
        if (irq\_was\_disabled && !irqs\_disabled()) \{  
            printk(KERN\_WARNING "parse\_args(): option '%s' enabled "  
                    "irq's!\\n", param);  
        \}  
        switch (ret) \{  
        case -ENOENT:  
            printk(KERN\_ERR "%s: Unknown parameter \`%s'\\n",  
                   name, param);  
            return ret;  
        case -ENOSPC:  
            printk(KERN\_ERR  
                   "%s: \`%s' too large for parameter \`%s'\\n",  
                   name, val ?: "", param);  
            return ret;  
        case 0:  
            break;  
        default:  
            printk(KERN\_ERR  
                   "%s: \`%s' invalid for parameter \`%s'\\n",  
                   name, val ?: "", param);  
            return ret;  
        \}  
    \}  
  
    /\* All parsed OK. \*/  
    return 0;  
\}  
  
接下来看下，一些内置模块的参数处理的问题。传递给模块的参数都是通过module\_param来实现的：  
include/linux/moduleparam.h  
 99 \#define module\_param(name, type, perm)                          \\  
100         module\_param\_named(name, name, type, perm)  
  
113 \#define module\_param\_named(name, value, type, perm)                        \\  
114         param\_check\_\#\#type(name, &(value));                                \\  
115         module\_param\_cb(name, &param\_ops\_\#\#type, &value, perm);            \\  
116         \_\_MODULE\_PARM\_TYPE(name, \#type)  
  
126 \#define module\_param\_cb(name, ops, arg, perm)                                     \\  
127         \_\_module\_param\_call(MODULE\_PARAM\_PREFIX,                                  \\  
128                             name, ops, arg, \_\_same\_type((arg), bool \*), perm    )  
  
142 \#define \_\_module\_param\_call(prefix, name, ops, arg, isbool, perm)       \\  
143         /\* Default value instead of permissions? \*/                     \\  
144         static int \_\_param\_perm\_check\_\#\#name \_\_attribute\_\_((unused)) =  \\  
145         BUILD\_BUG\_ON\_ZERO((perm) < 0 || (perm) > 0777 || ((perm) & 2))  \\  
146         + BUILD\_BUG\_ON\_ZERO(sizeof(""prefix) > MAX\_PARAM\_PREFIX\_LEN);   \\  
147         static const char \_\_param\_str\_\#\#name\[\] = prefix \#name;          \\  
148         static struct kernel\_param \_\_moduleparam\_const \_\_param\_\#\#name   \\  
149         \_\_used                                                          \\  
150     \_\_attribute\_\_ ((unused,\_\_section\_\_ ("\_\_param"),aligned(sizeof(void \*))))     \\  
151         = \{ \_\_param\_str\_\#\#name, ops, perm, isbool ? KPARAM\_ISBOOL : 0,  \\  
152             \{ arg \} \}  
这里也就是填充了 struct kernel\_param的结构体，并将这个变量标记为\_\_param段，以便于链接器将此变量装载到指定的段  
接下来我们来看struct kernel\_param这个结构：  
include/linux/moduleparam.h  
struct kernel\_param;  
  
struct kernel\_param\_ops \{  
    /\* Returns 0, or -errno.  arg is in kp->arg. \*/  
    int (\*set)(const char \*val, const struct kernel\_param \*kp);设置参数的函数  
    /\* Returns length written or -errno.  Buffer is 4k (ie. be short!) \*/  
    int (\*get)(char \*buffer, const struct kernel\_param \*kp);读取参数的函数  
    /\* Optional function to free kp->arg when module unloaded. \*/  
    void (\*free)(void \*arg);  
\};  
  
/\* Flag bits for kernel\_param.flags \*/  
\#define KPARAM\_ISBOOL        2  
  
struct kernel\_param \{  
    const char \*name;  
    const struct kernel\_param\_ops \*ops;  
    u16 perm;  
    u16 flags;  
    union \{ 传递给上面kernel\_param\_ops中两个函数的参数  
        void \*arg;  
        const struct kparam\_string \*str;  
        const struct kparam\_array \*arr;  
    \};  
\};  
  
/\* Special one for strings we want to copy into \*/  
struct kparam\_string \{  
    unsigned int maxlen;  
    char \*string;  
\};  
  
/\* Special one for arrays \*/  
struct kparam\_array  
\{  
    unsigned int max;  
    unsigned int \*num;  
    const struct kernel\_param\_ops \*ops;  
    unsigned int elemsize;  
    void \*elem;  
\};  
  
接下来来看parse\_one函数，其中early和一般的pase都是通过这个函数来解析：  
kernel/params.c  
static inline char dash2underscore(char c)  
\{  
    if (c == '-')  
        return '\_';  
    return c;  
\}  
  
static inline int parameq(const char \*input, const char \*paramname)  
\{  
    unsigned int i;  
    for (i = 0; dash2underscore(input\[i\]) == paramname\[i\]; i++)  
        if (input\[i\] == '\\0')  
            return 1;  
    return 0;  
\}  
  
static int parse\_one(char \*param,  
             char \*val,  
             const struct kernel\_param \*params,  
             unsigned num\_params,  
             int (\*handle\_unknown)(char \*param, char \*val))  
\{  
    unsigned int i;  
    int err;  
     如果是early\_param则直接跳过这步，而非early的，则要通过这步来设置一些内置模块的参数。  
    /\* Find parameter \*/  
    for (i = 0; i < num\_params; i++) \{  
        if (parameq(param, params\[i\].name)) \{  
            /\* Noone handled NULL, so do it here. \*/  
            if (!val && params\[i\].ops->set != param\_set\_bool) 调用参数设置函数来设置对应的参数。  
                return -EINVAL;  
            DEBUGP("They are equal!  Calling %p\\n",  
                   params\[i\].ops->set);  
            mutex\_lock(&param\_lock);  
            err = params\[i\].ops->set(val, &params\[i\]);  
            mutex\_unlock(&param\_lock);  
            return err;  
        \}  
    \}  
  
    if (handle\_unknown) \{  
        DEBUGP("Unknown argument: calling %p\\n", handle\_unknown);  
        return handle\_unknown(param, val);  
    \}  
  
    DEBUGP("Unknown argument \`%s'\\n", param);  
    return -ENOENT;  
\}  
这里之所以把所有的内核初始化参数都放在一个段里，主要是为了初始化成功后，释放这些空间。  
我们下来看一下内核编译完毕后的一些段的位置:  
[![21455Q5L-2.jpg][]][21455Q5L-2.jpg]  
  
右边就是每个段定义的相关的宏。在\_\_init\_start和\_\_init\_end之间的段严格按照顺序进行初始化，比如 core\_initcall宏修饰的函数就要比arch\_initcall宏定义的函数优先级高，所以就更早的调用。这个特性就可以使我们将一些优先级比较高的初始化函数放入相应比较高的段。。  
这里要注意，每个init宏，基本都会有个对应的exit宏，比如\_\_initial和\_\_exit等等。。  
内核中修饰的宏很多，我们下面只介绍一些常用的：  
\_\_devinit 用来标记一个设备的初始化函数，比如pci设备的probe函数，就是用这个宏来修饰。  
\_\_initcall这个已被废弃，现在实现为\_\_devinit的别名。  
剩下的宏需要去看内核的相关文档。。  
  
最后还要注意几点：  
1 当模块被静态的加入到内核中时，module\_init标记的函数只会被执行一次，因此当初始化成功后，内核会释放掉这块的内存。  
2 当模块静态假如内核，module\_exit在链接时就会被删除掉。  
这里的优化还有很多，比如热拔插如果不支持的话，很多设备的初始化函数都会在执行完一遍后，被丢弃掉。  
这里可以看到，如果模块被静态的编译进内核时，内核所做的内存优化会更多，虽然损失了更多的灵活性   
  
  
回到start\_arch中第822行，来看arm\_memblock\_init(&meminfo, mdesc);函数  
arch/arm/mm/init.c  
270 void \_\_init arm\_memblock\_init(struct meminfo \*mi, struct machine\_desc \*mdesc)  
271 \{  
272         int i;  
273  
274         memblock\_init();  
275         for (i = 0; i < mi->nr\_banks; i++)  
276                 memblock\_add(mi->bank\[i\].start, mi->bank\[i\].size);  
277  
278         /\* Register the kernel text, kernel data and initrd with memblock. \*/  
279 \#ifdef CONFIG\_XIP\_KERNEL  
280         memblock\_reserve(\_\_pa(\_data), \_end - \_data);  
281 \#else  
282         memblock\_reserve(\_\_pa(\_stext), \_end - \_stext);  
283 \#endif  
284 \#ifdef CONFIG\_BLK\_DEV\_INITRD  
285         if (phys\_initrd\_size) \{  
286                 memblock\_reserve(phys\_initrd\_start, phys\_initrd\_size);  
287  
288                 /\* Now convert initrd to virtual addresses \*/  
289                 initrd\_start = \_\_phys\_to\_virt(phys\_initrd\_start);  
290                 initrd\_end = initrd\_start + phys\_initrd\_size;  
291         \}  
292 \#endif  
293  
294         arm\_mm\_memblock\_reserve();  
295  
296         /\* reserve any platform specific memblock areas \*/  
297         if (mdesc->reserve)  
298                 mdesc->reserve();  
299  
300         memblock\_analyze();  
301         memblock\_dump\_all();  
302 \}  
这个函数保留了内存, 包括linux内核占用的代码数据段空间, initrd占用的空间 以及一些平台相关的内存  
第274行，memblock\_init()在mm/memblock.c里面被定义。  
void \_\_init memblock\_init(void)  
\{  
    /\* Create a dummy zero size MEMBLOCK which will get coalesced away later.  
     \* This simplifies the memblock\_add() code below...  
     \*/  
    memblock.memory.region\[0\].base = 0;  
    memblock.memory.region\[0\].size = 0;  
    memblock.memory.cnt = 1;  
  
    /\* Ditto. \*/  
    memblock.reserved.region\[0\].base = 0;  
    memblock.reserved.region\[0\].size = 0;  
    memblock.reserved.cnt = 1;  
\}  
其作用就是初始化memblock这个结构。memblock包含两个重要的成员，分别是memblock.memory和memblock.reserved.其分别代表系统中可用的内存和已经被保留的内存。  
memblock.memory和memblock.reserved被定义为以下结构：include/linux/memblock.h  
\#define MAX\_MEMBLOCK\_REGIONS 128  
  
struct memblock\_property \{  
    u64 base;  
    u64 size;  
\};  
  
struct memblock\_region \{  
    unsigned long cnt;  
    u64 size;  
    struct memblock\_property region\[MAX\_MEMBLOCK\_REGIONS+1\];  
\};  
  
struct memblock \{  
    unsigned long debug;  
    u64 rmo\_size;  
    struct memblock\_region memory;  
    struct memblock\_region reserved;  
\};  
276行，内存原始数据由u-boot传入，并在start\_arch中调用parse\_tags对它初始化（其详细过程请参看我后面的u-boot与linux内核间的参数传递过程分析），在初始化完memblock\_init后，memblock\_add调用memblock\_add\_region加入原始内存数据，

[21455R2b-1.jpg]: http://www.jfox.info/uploads/allimg/100908/21455R2b-1.jpg
[21455Q5L-2.jpg]: http://www.jfox.info/uploads/allimg/100908/21455Q5L-2.jpg