[转载请注明出处，，作者：张洪耿，patrick_zhg@hotmail.com]
本文通过整理之前研发的一个项目(ARM7TDMI +uCLinux)，分析内核启动过程及需要修改的文件，以供
内核移植者参考。整理过程中也同时参考了众多网友的帖子，在此谢过。由于整理过程匆忙，难免错误
及讲解的不够清楚之处，请各位网友指正，这里提前谢过。本文分以下部分进行介绍：
1. Bootloader 及内核解压
2. 内核启动方式介绍
3. 内核启动地址的确定
4. arch/armnommu/kernel/head-armv.S分析
5. start_kernel()函数分析
1. Bootloader 及内核解压
Bootloader 将内核加载到内存中，设定一些寄存器，然后将控制权交由内核，该过程中，关闭 MMU 功
能。通常，内核都是以压缩的方式存放，如 zImage，这里有两种解压方法：
使用内核自解压程序。
arch/arm/boot/compressed/head.S或 arch/arm/boot/compressed/head-xxxxx.S
arch/arm/boot/compressed/misc.c
在Bootloader 中增加解压功能。
使用该方法时内核不需要带有自解压功能，而使用Bootloader中的解压程序代替内核自解压程序。其工
作过程与内核自解压过程相似：Bootloader 把压缩方式的内核解压到内存中，然后跳转到内核入口处开
始执行。
2. 几种内核启动方式介绍
XIP (EXECUTE IN PLACE) 是指直接从存放代码的位置上启动运行。
2.1 非压缩，非 XIP
非 XIP 方式是指在运行之前需对代码进行重定位。该类型的内核以非压缩方式存放在 Flash 中，启动时
由Bootloader 加载到内存后运行。
2.2 非压缩，XIP
该类型的内核以非压缩格式存放在 ROM/Flash 中，不需要加载到内存就能运行，Bootloader直接跳转到
其存放地址执行。Data 段复制和 BSS 段清零的工作由内核自己完成。这种启动方式常用于内存空间有
限的系统中，另外，程序在ROM/Flash 中运行的速度相对较慢。
2.3 RAM 自解压
压缩格式的内核由开头一段自解压代码和压缩内核数据组成，由于以压缩格式存放，内核只能以非 XIP
方式运行。RAM 自解压过程如下：压缩内核存放于 ROM/Flash 中，Bootloader 启动后加载到内存中的
临时空间，然后跳转到压缩内核入口地址执行自解压代码，内核被解压到最终的目的地址然后运行。压
缩内核所占据的临时空间随后被 Linux回收利用。这种方式的内核在嵌入式产品中较为常见。
2.4 ROM 自解压
解压缩代码也能够以 XIP 的方式在 ROM/Flash 中运行。ROM 自解压过程如下：压缩内核存放在
ROM/Flash 中，不需要加载到内存就能运行，Bootloader 直接跳转到其存放地址执行其自解压代码，将
压缩内核解压到最终的目的地址并运行。ROM 自解压方式存放的内核解压缩速度慢，而且也不能节省
内存空间。
3. 内核启动地址的确定
内核自解压方式
Head.S/head-XXX.S 获得内核解压后首地址 ZREALADDR，然后解压内核，并把解压后的内核放在
ZREALADDR的位置上，最后跳转到ZREALADDR地址上，开始真正的内核启动。
arch/armnommu/boot/Makefile，定义 ZRELADDR 和 ZTEXTADDR。ZTEXTADDR 是自解压代码的起始
地址，如果从内存启动内核，设置为0 即可，如果从 Rom/Flash启动，则设置ZTEXTADDR为相应的值。
ZRELADDR是内核解压缩后的执行地址。
arch/armnommu/boot/compressed/vmlinux.ld,引用 LOAD_ADDR和 TEXT_START。
arch/armnommu/boot/compressed/Makefile, 通过如下一行：
SEDFLAGS = s/TEXT_START/$(ZTEXTADDR)/;s/LOAD_ADDR/$(ZRELADDR)/;
使得TEXT_START = ZTEXTADDR，LOAD_ADDR = ZRELADDR。
说明：
执行完decompress_kernel函数后,代码跳回head.S/head-XXX.S中,检查解压缩之后的kernel起始地址是否
紧挨着 kernel image。如果是,beqcall_kernel,执行解压后的 kernel。如果解压缩之后的 kernel 起始地址不
是紧挨着 kernelimage,则执行 relocate,将其拷贝到紧接着 kernel image 的地方,然后跳转,执行解压后的
kernel。
Bootloader 解压方式
Bootloader把解压后的内核放在内存的 TEXTADDR位置上，然后跳转到 TEXTADDR位置上，开始内核
启动。
arch/armnommu/Makefile，一般设置 TEXTADDR 为 PAGE_OFF+0x8000，如定义为 0x00008000,
0xC0008000等。
arch/armnommu/vmlinux.lds，引用 TEXTADDR
4. arch/armnommu/kernel/head-armv.S
该文件是内核最先执行的一个文件，包括内核入口ENTRY(stext)到 start_kernel间的初始化代码，主要作
用是检查CPUID，Architecture Type，初始化 BSS等操作，并跳到 start_kernel 函数。在执行前，处理器
应满足以下状态：
r0 - should be 0
r1 - unique architecture number
MMU - off
I-cache - on or off
D-cache – off
/* 部分源代码分析 */
/* 内核入口点 */
ENTRY(stext)
/* 程序状态，禁止FIQ、IRQ，设定 SVC模式 */
mov r0, #F_BIT | I_BIT | MODE_SVC@ make sure svc mode
/* 置当前程序状态寄存器 */
msr cpsr_c, r0 @ and all irqs disabled
/* 判断 CPU类型，查找运行的CPU ID值与 Linux编译支持的 ID值是否支持 */
bl __lookup_processor_type
/* 跳到__error */
teq r10, #0 @ invalid processor?
moveq r0, #'p' @ yes, error 'p'
beq __error
/* 判断体系类型，查看R1 寄存器的 Architecture Type 值是否支持 */
bl __lookup_architecture_type
/* 不支持，跳到出错 */
teq r7, #0 @ invalid architecture?
moveq r0, #'a' @ yes, error 'a'
beq __error /* 创建核心页表 */
bl __create_page_tables
adr lr, __ret @ return address
add pc, r10, #12 @ initialise processor
/* 跳转到 start_kernel 函数 */
b start_kernel
__lookup_processor_type 这个函数根据芯片的ID从 proc.info获取 proc_info_list 结构， proc_info_list 结构
定义在include/asm-armnommu/proginfo.h中，该结构的数据定义在arch/armnommu/mm/proc-arm*.S 文件
中，ARM7TDMI 系列芯片的 proc_info_list 数据定义在 arch/armnommu/mm/proc-arm6,7.S 文件中。函数
__lookup_architecture_type 从 arch.info 获取 machine_desc 结构， machine_desc 结构定义在
include/asm-armnommu/mach/arch.h 中，针对不同 arch 的数据定义在 arch/armnommu/mach-*/arch.c 文件
中。
在这里如果知道processor_type 和 architecture_type,可以直接对相应寄存器进行赋值。
5. start_kernel()函数分析
下面对start_kernel()函数及其相关函数进行分析。
5.1 lock_kernel()
/* Getting the big kernel lock.
* This cannot happen asynchronously,
* so we only need to worry about other
* CPU's.
*/
extern __inline__ void lock_kernel(void)
{
if (!++current->lock_depth)
spin_lock(&kernel_flag);
}
kernel_flag 是一个内核大自旋锁，所有进程都通过这个大锁来实现向内核态的迁移。只有获得这个大自
旋锁的处理器可以进入内核，如中断处理程序等。在任何一对lock_kernel／unlock_kernel函数里至多可
以有一个程序占用 CPU。进程的 lock_depth 成员初始化为-1，在 kerenl/fork.c 文件中设置。在它小于 0
时（恒为-1），进程不拥有内核锁；当大于或等于0 时，进程得到内核锁。
5.2 setup_arch()
setup_arch()函数做体系相关的初始化工作，函数的定义在 arch/armnommu/kernel/setup.c文件中，
主要涉及下列主要函数及代码。
5.2.1 setup_processor()
该函数主要通过
for (list = &__proc_info_begin; list < &__proc_info_end ; list++)
if ((processor_id & list->cpu_mask) == list->cpu_val)
break;
这样一个循环来在.proc.info段中寻找匹配的processor_id，processor_id在 head_armv.S文件
中设置。
5.2.2 setup_architecture(machine_arch_type)
该函数获得体系结构的信息，返回mach-xxx/arch.c 文件中定义的 machine 结构体的指针， 包含以下内容：
MACHINE_START (xxx, “xxx”)
MAINTAINER ("xxx")
BOOT_MEM (xxx, xxx, xxx)
FIXUP (xxx) MAPIO (xxx)
INITIRQ (xxx)
MACHINE_END
5.2.3内存设置代码
if (meminfo.nr_banks == 0)
{
meminfo.nr_banks = 1;
meminfo.bank[0].start = PHYS_OFFSET;
meminfo.bank[0].size = MEM_SIZE;
}
meminfo结构表明内存情况，是对物理内存结构 meminfo 的默认初始化。nr_banks 指定内存块的数量，
bank 指定每块内存的范围，PHYS_OFFSET 指定某块内存块的开始地址，MEM_SIZE 指定某块内存块长
度。PHYS_OFFSET 和 MEM_SIZE 都定义在 include/asm-armnommu/arch-XXX/memory.h 文件中，其中
PHYS_OFFSET 是内存的开始地址，MEM_SIZE 就是内存的结束地址。这个结构在接下来内存的初始化
代码中起重要作用。
5.2.4 内核内存空间管理
init_mm.start_code = (unsigned long) &_text; 内核代码段开始
init_mm.end_code = (unsigned long) &_etext; 内核代码段结束
init_mm.end_data = (unsigned long) &_edata; 内核数据段开始
init_mm.brk = (unsigned long) &_end; 内核数据段结束
每一个任务都有一个 mm_struct 结构管理其内存空间，init_mm 是内核的 mm_struct。其中设置成员变量
* mmap指向自己， 意味着内核只有一个内存管理结构，设置 pgd=swapper_pg_dir，
swapper_pg_dir 是内核的页目录，ARM 体系结构的内核页目录大小定义为 16k。init_mm 定义了整个内
核的内存空间，内核线程属于内核代码，同样使用内核空间，其访问内存空间的权限与内核一样。
5.2.5 内存结构初始化
bootmem_init(&meminfo)函数根据 meminfo 进行内存结构初始化。bootmem_init(&meminfo)函数中调用
reserve_node_zero(bootmap_pfn, bootmap_pages)函数，这个函数的作用是保留一部分内存使之不能被动态
分配。这些内存块包括：
reserve_bootmem_node(pgdat, __pa(&_stext), &_end - &_stext); /*内核所占用地址空间*/
reserve_bootmem_node(pgdat, bootmap_pfn<
/*bootmem结构所占用地址空间*/
5.2.6 paging_init(&meminfo, mdesc)
创建内核页表，映射所有物理内存和 IO 空间，对于不同的处理器，该函数差别比较大。下面简单描述
一下 ARM 体系结构的存储系统及MMU相关的概念。
在 ARM 存储系统中，使用内存管理单元(MMU)实现虚拟地址到实际物理地址的映射。利用 MMU，可
把SDRAM的地址完全映射到0x0起始的一片连续地址空间，而把原来占据这片空间的FLASH或者ROM
映射到其他不相冲突的存储空间位置。例如，FLASH 的地址从 0x00000000～0x00FFFFFF，而 SDRAM
的地址范围是 0x3000 0000～0x3lFFFFFF，则可把 SDRAM 地址映射为 0x00000000～0xlFFFFFF，而
FLASH 的地址可以映射到 0x90000000～0x90FFFFFF(此处地址空间为空闲，未被占用)。映射完成后，
如果处理器发生异常，假设依然为 IRQ 中断，PC 指针指向 0xl8 处的地址，而这个时候 PC 实际上是从
位于物理地址的 0x30000018 处读取指令。通过 MMU的映射，则可实现程序完全运行在 SDRAM 之中。
在实际的应用中．可能会把两片不连续的物理地址空间分配给 SDRAM。而在操作系统中，习惯于把
SDRAM 的空间连续起来，方便内存管理，且应用程序申请大块的内存时，操作系统内核也可方便地分
配。通过 MMU可实现不连续的物理地址空间映射为连续的虚拟地址空间。操作系统内核或者一些比较
关键的代码，一般是不希望被用户应用程序访问。通过MMU可以控制地址空间的访问权限，从而保护这些代码不被破坏。
MMU 的实现过程，实际上就是一个查表映射的过程。建立页表是实现 MMU 功能不可缺少的一步。页
表位于系统的内存中，页表的每一项对应于一个虚拟地址到物理地址的映射。每一项的长度即是一个字
的长度(在 ARM 中，一个字的长度被定义为 4Bytes)。页表项除完成虚拟地址到物理地址的映射功能之
外，还定义了访问权限和缓冲特性等。
MMU 的映射分为两种，一级页表的变换和二级页表变换。两者的不同之处就是实现的变换地址空间大
小不同。一级页表变换支持 1 M大小的存储空间的映射，而二级可以支持64 kB，4 kB和1 kB大小地
址空间的映射。
动态表(页表)的大小＝表项数＊每个表项所需的位数，即为整个内存空间建立索引表时，需要多大空间
存放索引表本身。
表项数＝虚拟地址空间/每页大小
每个表项所需的位数＝Log(实际页表数)+适当控制位数
实际页表数 ＝物理地址空间/每页大小
下面分析paging_init（）函数的代码。
在paging_init 中分配起始页（即第 0 页）地址：
zero_page = 0xCXXXXXXX
memtable_init(mi); 如果当前微处理器带有 MMU，则为系统内存创建页表；如果当前微处理器不支持
MMU，比如 ARM7TDMI 上移植 uCLinux 操作系统时，则不需要此类步骤。可以通过如下一个宏定义
实现灵活控制，对于带有 MMU的微处理器而言，memtable_init(mi)是 paging_init()中最重要的函数。
#ifndef CONFIG_UCLINUX
/* initialise the page tables. */
memtable_init(mi);
……（此处省略若干代码）
free_area_init_node(node, pgdat, 0, zone_size,
bdata->node_boot_start, zhole_size);
}
#else /* 针对不带 MMU微处理器 */
{
/*****************************************************/
定义物理内存区域管理
/*****************************************************/
unsigned long zone_size[MAX_NR_ZONES] = {0,0,0};
zone_size[ZONE_DMA] = 0;
zone_size[ZONE_NORMAL] = (END_MEM - PAGE_OFFSET) >> PAGE_SHIFT;
free_area_init_node(0, NULL, NULL, zone_size, PAGE_OFFSET, NULL);
}
#endif
uCLinux与其它嵌入式 Linux最大的区别就是 MMU管理这一块，从上面代码就明显可以看到这点区别。
下面继续讨论针对带 MMU的微处理器的内存管理。
void __init memtable_init(struct meminfo *mi)
{ struct map_desc *init_maps, *p, *q;
unsigned long address = 0;
int i;
init_maps = p = alloc_bootmem_low_pages(PAGE_SIZE);
/*******************************************************/
其中map_desc定义为：
struct map_desc {
unsigned long virtual;
unsigned long physical;
unsigned long length;
int domain:4, // 页表的 domain
prot_read:1, // 读保护标志
prot_write:1, // 写保护标志
cacheable:1, // 是否使用 cache
bufferable:1, // 是否使用 write buffer
last:1; //空
};init_maps /* map_desc 是区段及其属性的定义 */
下面代码对 meminfo 的区段进行遍历，在嵌入式系统中列举所有可映射的内存，例如 32M SDRAM, 4M
FLASH等，用meminfo记录这些内存区段。同时填写 init_maps 中的各项内容。meminfo结构如下：
struct meminfo {
int nr_banks;
unsigned long end;
struct {
unsigned long start;
unsigned long size;
int node;
} bank[NR_BANKS];
};
/********************************************************/
for (i = 0; i < mi->nr_banks; i++)
{
if (mi->bank.size == 0)
continue;
p->physical = mi->bank.start;
p->virtual = __phys_to_virt(p->physical);
p->length = mi->bank.size;
p->domain = DOMAIN_KERNEL;
p->prot_read = 0;
p->prot_write = 1;
p->cacheable = 1; //使用 Cache
p->bufferable = 1; //使用 write buffer
p ++; //下一个区段
}
/* 如果系统存在 FLASH,执行以下代码 */
#ifdef FLUSH_BASE
p->physical = FLUSH_BASE_PHYS; p->virtual = FLUSH_BASE;
p->length = PGDIR_SIZE;
p->domain = DOMAIN_KERNEL;
p->prot_read = 1;
p->prot_write = 0;
p->cacheable = 1;
p->bufferable = 1;
p ++;
#endif
/***********************************************************/
接下来的代码是逐个区段建立页表
/***********************************************************/
q = init_maps;
do {
if (address < q->virtual || q == p) {
/*******************************************************************************/
由于内核空间是从某个地址开始，如0xC0000000，所以 0xC000 0000 以前的页表项全部清空
clear_mapping在 mm-armv.c 中定义，其中 clear_mapping()是个宏，根据处理器的不同，可以被展开为如
下代码
cpu_XXX_set_pmd(((pmd_t *)(((&init_mm )->pgd+ (( virt) >> 20 )))),((pmd_t){( 0 )}));
其中 init_mm 为内核的 mm_struct，pgd 指向 swapper_pg_dir，在 arch/arm/kernel/init_task.c 中定义。
cpu_XXX_set_pmd 定义在 proc_armXXX.S文件中，参见 ENTRY(cpu_XXX_set_pmd) 处代码。
/*********************************************************************************/
clear_mapping(address);
/* 每个表项增加 1M */
address += PGDIR_SIZE;
} else {
/* 构建内存页表 */
create_mapping(q);
address = q->virtual + q->length;
address = (address + PGDIR_SIZE - 1) & PGDIR_MASK;
q ++;
}
} while (address != 0);
/ * create_mapping函数也在 mm-armv.c中定义 */
static void __init create_mapping(struct map_desc *md)
{
unsigned long virt, length;
int prot_sect, prot_pte;
long off;
/*******************************************************************************/ 大部分应用中均采用 1 级 section模式的地址映射，一个section的大小为1M，也就是说从逻辑地址到物
理地址的转变是这样的一个过程：
一个 32 位的地址，高 12 位决定了该地址在页表中的 index，这个 index 的内容决定了该逻辑 section 对
应的物理section；低 20 位决定了该地址在section中的偏移（index）。例如：从 0x0～0xFFFFFFFF 的地
址空间总共可以分成 0x1000（4K）个 section（每个section大小为1M），页表中每项的大小为 32 个 bit，
因此页表的大小为0x4000（16K）。
每个页表项的内容如下:
bit: 31 20 19 12 11 10 9 8 5 4 3 2 1 0
content: Section对应的物理地址 NULL AP 0 Domain 1 C B 1 0
最低两位（10）是 section分页的标识。
AP：Access Permission，区分只读、读写、SVC＆其它模式。
Domain：每个 section 都属于某个 Domain，每个 Domain 的属性由寄存器控制。一般都只要包含两个
Domain，一个可访问地址空间； 另一个不可访问地址空间。
C、B：这两位决定了该 section的 cache＆write buffer 属性，这与该段的用途(RO or RW)有密切关系。不
同的用途要做不同的设置。
C B 具体含义
0 0 无 cache，无写缓冲，任何对 memory的读写都反映到总线上。对 memory 的操作过程中CPU需要
等待。
0 1 无cache，有写缓冲，读操作直接反映到总线上。写操作 CPU 将数据写入到写缓冲后继续运行，由
写缓冲进行写回操作。
1 0 有 cache， 写通模式， 读操作首先考虑 cache hit； 写操作时直接将数据写入写缓冲， 如果同时出现cache
hit，那么也更新cache。
1 1 有 cache，写回模式，读操作首先考虑cache hit；写操作也首先考虑 cache hit。
由于ARM 中 section表项的权限位和 page 表项的位置不同， 以下代码根据 struct map_desc 中的保护标
志，分别计算页表项中的 AP, Domain 和 CB标志位。
/*******************************************************************************/
prot_pte = L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_DIRTY |
(md->prot_read ? L_PTE_USER : 0) |
(md->prot_write ? L_PTE_WRITE : 0) |
(md->cacheable ? L_PTE_CACHEABLE : 0) |
(md->bufferable ? L_PTE_BUFFERABLE : 0);
prot_sect = PMD_TYPE_SECT | PMD_DOMAIN(md->domain) |
(md->prot_read ? PMD_SECT_AP_READ : 0) |
(md->prot_write ? PMD_SECT_AP_WRITE : 0) |
(md->cacheable ? PMD_SECT_CACHEABLE : 0) |
(md->bufferable ? PMD_SECT_BUFFERABLE : 0);
/********************************************************************/
设置虚拟地址，偏移地址和内存length
/********************************************************************/
virt = md->virtual;
off = md->physical - virt;
length = md->length;
/********************************************************************/
建立虚拟地址到物理地址的映射
/********************************************************************/
while ((virt & 0xfffff || (virt + off) & 0xfffff) && length >= PAGE_SIZE) {
alloc_init_page(virt, virt + off, md->domain, prot_pte);
virt += PAGE_SIZE;
length -= PAGE_SIZE;
}
while (length >= PGDIR_SIZE) {
alloc_init_section(virt, virt + off, prot_sect);
virt += PGDIR_SIZE;
length -= PGDIR_SIZE;
}
while (length >= PAGE_SIZE) {
alloc_init_page(virt, virt + off, md->domain, prot_pte);
virt += PAGE_SIZE;
length -= PAGE_SIZE;
}
/*************************************************************************/
create_mapping 的作用是设置虚地址virt 到物理地址virt + off_set 的映射页目录和页表。
/*************************************************************************/
/* 映射中断向量表区域 */
init_maps->physical = virt_to_phys(init_maps);
init_maps->virtual = vectors_base();
init_maps->length = PAGE_SIZE;
init_maps->domain = DOMAIN_USER;
init_maps->prot_read = 0;
init_maps->prot_write = 0;
init_maps->cacheable = 1;
init_maps->bufferable = 0;
create_mapping(init_maps);
中断向量表的虚地址 init_maps，是用 alloc_bootmem_low_pages 分配的，通常是在 PAGE_OFF+0x8000
前面的某一页，vectors_base()是个宏，ARM 规定中断向量表的地址只能是 0 或 0xFFFF0000，所以上述
代码映射一页到0 或 0xFFFF0000，中断处理程序中的部分代码也被拷贝到这一页中。
5.3 parse_options()
分析由内核引导程序发送给内核的启动选项，在初始化过程中按照某些选项运行，并将剩余部分传送给
init 进程。这些选项可能已经存储在配置文件中，也可能是由用户在系统启动时敲入的。但内核并不关
心这些，这些细节都是内核引导程序关注的内容，嵌入式系统更是如此。
5.4 trap_init() 这个函数用来做体系相关的中断处理的初始化，在该函数中调用__trap_init((void*)vectors_base())函数将
exceptionvector 设置到vectors_base 开始的地址上。__trap_init 函数位于entry-armv.S文件中，对于 ARM
处理器，共有复位、未定义指令、SWI、预取终止、数据终止、IRQ和FIQ几种方式。SWI 主要用来实
现系统调用，而产生了 IRQ之后，通过 exceptionvector 进入中断处理过程，执行do_IRQ函数。
armnommu 的 trap_init（）函数在 arch/armnommu/kernel/traps.c 文件中。vectors_base 是写中断向量的开
始地址，在include/asm-armnommu/proc-armv/system.h文件中设置，地址为0或0XFFFF0000。
ENTRY(__trap_init)
stmfd sp!, {r4 - r6, lr}
mrs r1, cpsr @ code from 2.0.38
bic r1, r1, #MODE_MASK @ clear mode bits /* 设置svc 模式，disable IRQ,FIQ */
orr r1, r1, #I_BIT|F_BIT|MODE_SVC @ set SVC mode, disable IRQ,FIQ
msr cpsr, r1
adr r1, .LCvectors @ set up the vectors
ldmia r1, {r1, r2, r3, r4, r5, r6, ip, lr}
stmia r0, {r1, r2, r3, r4, r5, r6, ip, lr} /* 拷贝异常向量 */
add r2, r0, #0x200
adr r0, __stubs_start @ copy stubs to 0x200
adr r1, __stubs_end
1: ldr r3, [r0], #4
str r3, [r2], #4
cmp r0, r1
blt 1b
LOADREGS(fd, sp!, {r4 - r6, pc})
__stubs_start 到__stubs_end 的地址中包含了异常处理的代码，因此拷贝到vectors_base+0x200的位置上。
5.5 init_IRQ()
void __init init_IRQ(void)
{
extern void init_dma(void);
int irq;
for (irq = 0; irq < NR_IRQS; irq++) {
irq_desc[irq].probe_ok = 0;
irq_desc[irq].valid = 0;
irq_desc[irq].noautoenable = 0;
irq_desc[irq].mask_ack = dummy_mask_unmask_irq;
irq_desc[irq].mask = dummy_mask_unmask_irq;
irq_desc[irq].unmask = dummy_mask_unmask_irq;
}
CSR_WRITE(AIC_MDCR, 0x7FFFE); /* disable all interrupts */
CSR_WRITE(CAHCNF,0x0);/*Close Cache*/
CSR_WRITE(CAHCON,0x87);/*Flush Cache*/
while(CSR_READ(CAHCON)!=0);
CSR_WRITE(CAHCNF,0x7);/*Open Cache*/
init_arch_irq(); init_dma();
}
这个函数用来做体系相关的 irq 处理的初始化，irq_desc 数组是用来描述 IRQ 的请求队列，每一个中断
号分配一个irq_desc结构，组成了一个数组。NR_IRQS代表中断数目，这里只是对中断结构irq_desc进
行了初始化。在默认的初始化 完成后调用初始化函数 init_arch_irq ，先执行
arch/armnommu/kernel/irq-arch.c 文件中的函数 genarch_init_irq() ，然后就执行
include/asm-armnommu/arch-xxxx/irq.h中的 inline 函数irq_init_irq，在这里对 irq_desc进行了实质的初始
化。其中mask用阻塞中断；unmask用来取消阻塞；mask_ack的作用是阻塞中断，同时还回应 ack给硬
件表示这个中断已经被处理了，否则硬件将再次发生同一个中断。这里，不是所有硬件需要这个ack回
应，所以很多时候mask_ack 与 mask用的是同一个函数。
接下来执行 init_dma（）函数，如果不支持 DMA，可以设置 include/asm-armnommu/arch-xxxx/dma.h 中
的 MAX_DMA_CHANNELS 为 0，这样在 arch/armnommu/kernel/dma.c 文件中会根据这个定义使用不同
的函数。
5.6 sched_init()
初始化系统调度进程，主要对定时器机制和时钟中断的BottomHalf 的初始化函数进行设置。与时间相关
的初始化过程主要有两步：（1）调用 init_timervecs()函数初始化内核定时器机制； （2）调用 init_bh()函
数将BH向量 TIMER_BH、 TQUEUE_BH和 IMMEDIATE_BH 所对应的 BH函数分别设置成 timer_bh()、
tqueue_bh()和 immediate_bh()函数
5.7 softirq_init()
内核的软中断机制初始化函数。调用 tasklet_init初始化 tasklet_struct结构，软中断的个数为32 个。用于
bh 的 tasklet_struct 结构调用 tasklet_init()以后，它们的函数指针 func 全都指向 bh_action()。bh_action 就
是tasklet 实现bh 机制的代码，但此时具体的bh 函数还没有指定。
HI_SOFTIRQ 用于实现 bottom half，TASKLET_SOFTIRQ用于公共的 tasklet。
open_softirq(TASKLET_SOFTIRQ, tasklet_action, NULL); /* 初始化公共的 tasklet_struct 要用到的软中断
*/
open_softirq(HI_SOFTIRQ, tasklet_hi_action, NULL); /* 初始化 tasklet_struct 实现的 bottom half调用 */
这里顺便讲一下软中断的执行函数 do_softirq()。
软中断服务不允许在一个硬中断服务程序内部执行，也不允许在一个软中断服务程序内部执行，所以通
过 in_interrupt()加以检查。h->action 就是串行化执行软中断，当 bh 的 tasklet_struct 链入的时候，就能
在这里执行，在bh里重新锁定了所有CPU， 导致一个时间只有一个CPU可以执行bh函数，但是do_softirq()
是可以在多CPU上同时执行的。而每个 tasklet_struct在一个时间上是不会出现在两个 CPU上的。另外，
只有当Linux初始化完成开启中断后，中断系统才可以开始工作。
5.8 time_init()
这个函数用来做体系相关的 timer 的初始化，armnommu 的在 arch/armnommu/kernel/time.c。这里调用了
在include/asm-armnommu/arch-xxxx/time.h中的 inline 函数 setup_timer，setup_timer（）函数的设计与硬
件设计紧密相关，主要是根据硬件设计情况设置时钟中断号和时钟频率等。
void __inline__ setup_timer (void)
{
/*----- disable timer -----*/
CSR_WRITE(TCR0, xxx);
CSR_WRITE (AIC_SCR7, xxx); /* setting priority level to high */
/* timer 0: 100 ticks/sec */
CSR_WRITE(TICR0, xxx);
timer_irq.handler = xxxxxx_timer_interrupt;
setup_arm_irq(IRQ_TIMER, &timer_irq); /* IRQ_TIMER is the interrupt number */
INT_ENABLE(IRQ_TIMER);
/* Clear interrupt flag */
CSR_WRITE(TISR, xxx);
/* enable timer */
CSR_WRITE(TCR0, xxx);
}
5.9 console_init()
控制台初始化。控制台也是一种驱动程序，由于其特殊性，提前到该处完成初始化，主要是为了提前看
到输出信息，据此判断内核运行情况。很多嵌入式Linux操作系统由于没有在/dev目录下正确配置console
设备，造成启动时发生诸如 unable to open an initialconsole的错误。
/*******************************************************************************/
init_modules()函数到 smp_init()函数之间的代码一般不需要作修改，
如果平台具有特殊性，也只需对相关函数进行必要修改。
这里简单注明了一下各个函数的功能，以便了解。
/*******************************************************************************/
5.10 init_modules()
模块初始化。如果编译内核时使能该选项，则内核支持模块化加载/卸载功能
5.11 kmem_cache_init()
内核Cache 初始化。
5.12 sti()
使能中断，这里开始，中断系统开始正常工作。
5.13 calibrate_delay()
近似计算 BogoMIPS 数字的内核函数。作为第一次估算，calibrate_delay 计算出在每一秒内执行多少次
__delay循环，也就是每个定时器滴答（timer tick）―百分之一秒内延时循环可以执行多少次。这种计算
只是一种估算，结果并不能精确到纳秒，但这个数字供内核使用已经足够精确了。
BogoMIPS的数字由内核计算并在系统初始化的时候打印。它近似的给出了每秒钟CPU可以执行一个短
延迟循环的次数。在内核中，这个结果主要用于需要等待非常短周期的设备驱动程序――例如，等待几
微秒并查看设备的某些信息是否已经可用。
计算一个定时器滴答内可以执行多少次循环需要在滴答开始时就开始计数，或者应该尽可能与它接近。
全局变量jiffies 中存储了从内核开始保持跟踪时间开始到现在已经经过的定时器滴答数， jiffies 保持异
步更新，在一个中断内——每秒一百次，内核暂时挂起正在处理的内容，更新变量，然后继续刚才的工
作。
5.14 mem_init()
内存初始化。本函数通过内存碎片的重组等方法标记当前剩余内存, 设置内存上下界和页表项初始值。
5.15 kmem_cache_sizes_init() 内核内存管理器的初始化，也就是初始化 cache 和 SLAB分配机制。
5.16 pgtable_cache_init()
页表cache 初始化。
5.17 fork_init()
这里根据硬件的内存情况，如果计算出的 max_threads 数量太大，可以自行定义。
5.18 proc_caches_init();
为proc 文件系统创建高速缓冲
5.19 vfs_caches_init(num_physpages);
为VFS创建 SLAB高速缓冲
5.20 buffer_init(num_physpages);
初始化buffer
5.21 page_cache_init(num_physpages);
页缓冲初始化
5.22 signals_init();
创建信号队列高速缓冲
5.23 proc_root_init();
在内存中创建包括根结点在内的所有节点
5.24 check_bugs();
检查与处理器相关的 bug
5.25 smp_init();
5.26 rest_init(); 此函数调用kernel_thread(init, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGNAL)函
数。
5.26.1 kernel_thread()函数分析
这里调用了 arch/armnommu/kernel/process.c 中的函数 kernel_thread，kernel_thread 函数中通过
__syscall(clone) 创建新线程。 __syscall(clone)函数参见 armnommu/kernel目录下的entry-common.S 文件。
5.26.2 init()完成下列功能：
Init()函数通过kernel_thread(init, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGNAL)的回调函数执
行，完成下列功能。
do_basic_setup()
在该函数里，sock_init()函数进行网络相关的初始化，占用相当多的内存，如果所开发系统不支持网络功
能，可以把该函数的执行注释掉。
do_initcalls()实现驱动的初始化, 这里需要与vmlinux.lds 联系起来看才能明白其中奥妙。
static void __init do_initcalls(void)
{
initcall_t *call;
call = &__initcall_start; do {
(*call)();
call++;
} while (call < &__initcall_end);
/* Make sure there is no pending stuff from the initcall sequence */
flush_scheduled_tasks();
}
查看 /arch/i386/vmlinux.lds，其中有一段代码
__initcall_start = .;
.initcall.init : { *(.initcall.init) }
__initcall_end = .;
其含义是__initcall_start 指向代码节.initcall.init的节首，而__initcall_end指向.initcall.init的节尾。
do_initcalls 所作的是系统中有关驱动部分的初始化工作，那么这些函数指针数据是怎样放到
了.initcall.init节呢？在 include/linux/init.h文件中有如下3 个定义：
1. #define __init_call __attribute__ ((unused,__section__ (".initcall.init")))
__attribute__的含义就是构建一个在.initcall.init节的指向初始函数的指针。
2. #define __initcall(fn) static initcall_t __initcall_##fn __init_call = fn
##意思就是在可变参数使用宏定义的时候构建一个变量名称为所指向的函数的名称，并且在前面加上
__initcall_
3. #define module_init(x) __initcall(x);
很多驱动中都有类似 module_init(usb_init)的代码，通过该宏定义逐层解释存放到.initcall.int 节中。
blkmem相关的修改(do_initcalls()初始化驱动时执行此代码)
在 blkmem_init()函数中，调用了 blk_init_queue()函数，blk_init_queue()函数调用了 blk_init_free_list()函
数，blk_init_free_list()函数又调用了 blk_grow_request_list() 函数，在这个函数中会kmem_cache_alloc出
nr_requests 个 request 结构体。
这里如果 nr_requests 的值太大，则将占用过多的内存，将造成硬件内存不够，因此可以根据实际情况将
其替换成了较小的值，比如 32、16 等。
free_initmem
这个函数在arch/armnommu/mm/init.c 文件中，其作用就是对init节的释放，也可以通过修改代码指定为
不释放。
5.26.3 init 执行过程
在内核引导结束并启动 init 之后，系统就转入用户态的运行，在这之后创建的一切进程，都是在用户态
进行。这里先要清楚一个概念：就是init 进程虽然是从内核开始的， 即在前面所讲的 init/main.c 中的 init()
函数在启动后就已经是一个核心线程，但在转到执行 init程序（如 /sbin/init）之后，内核中的 init()就变
成了/sbin/init 程序，状态也转变成了用户态，也就是说核心线程变成了一个普通的进程。这样一来，内
核中的init函数实际上只是用户态init 进程的入口，它在执行execve("/sbin/init",argv_init, envp_init)时改
变成为一个普通的用户进程。这也就是 exec 函数的乾坤大挪移法，在 exec 函数调用其他程序时，当前
进程被其他进程“灵魂附体”。
除此之外，它们的代码来源也有差别，内核中的init()函数的源代码在/init/main.c中，是内核的一部
分。而/sbin/init 程序的源代码是应用程序。
init 程序启动之后，要完成以下任务：检查文件系统，启动各种后台服务进程，最后为每个终端和虚拟
控制台启动一个getty进程供用户登录。由于所有其它用户进程都是由init 派生的，因此它又是其它一切
用户进程的父进程。
init 进程启动后，按照/etc/inittab的内容进程系统设置。很多嵌入式系统用的是 BusyBox 的 init，它与一般所使用的init 不一样，会先执行/etc/init.d/rcS而非/etc/rc.d/rc.sysinit。
小结：
本想多整理一些相关资料，无奈又要开始新项目的奔波，start_kernel()函数也刚好差不多讲完了，分析
的不是很深入，希望对嵌入式Linux移植的网友们有一些帮助。最后列举下面几处未整理的知识点，有
兴趣的网友可作进一步探讨。
text.init 和 data.init 说明
__init 标示符在 gcc 编译器中指定将该函数置于内核的特定区域。在内核完成自身初始化之后，就试图
释放这个特定区域。实际上，内核中存在两个这样的区域，.text.init和.data.init――第一个是代码初始化
使用的，另外一个是数据初始化使用的。另外也可以看到 __initfunc 和__initdata 标志，前者和__init 类
似，标志初始化专用代码，后者则标志初始化专用数据。
System.map内核符号表
irq的处理过程
Linux内核调度过程
