走进start_kernel尾声

5.11 走进start_kernel尾声

中断体系建立起来后，虽然后面还有很多行代码，但是都是些比较好理解的初始化函数了，也就是说start_kernel进入尾声了。

5.11.1 初始化slab的后续工作

继续分析start_kenel的下一个函数，613行，profile_init函数，用于对系统剖析做相关初始化，系统剖析用于系统调用：

 

int __ref profile_init(void) {        int buffer_bytes;        if (!prof_on)               return 0;          /* only text is profiled */        prof_len = (_etext - _stext) >> prof_shift;        buffer_bytes = prof_len*sizeof(atomic_t);          if (!alloc_cpumask_var(&prof_cpu_mask, GFP_KERNEL))               return -ENOMEM;          cpumask_copy(prof_cpu_mask, cpu_possible_mask);          prof_buffer = kzalloc(buffer_bytes, GFP_KERNEL|__GFP_NOWARN);        if (prof_buffer)               return 0;          prof_buffer = alloc_pages_exact(buffer_bytes,                                    GFP_KERNEL|__GFP_ZERO|__GFP_NOWARN);        if (prof_buffer)               return 0;          prof_buffer = vmalloc(buffer_bytes);        if (prof_buffer) {               memset(prof_buffer, 0, buffer_bytes);               return 0;        }          free_cpumask_var(prof_cpu_mask);        return -ENOMEM; }

 

函数无非就是初始化一些简单的全局变量。继续在start_kenel中前进，614~616行，根据irqs_disabled是否返回成功而打印一些信息。617行，由于CONFIG_PROVE_LOCKING没有被配置，所以early_boot_irqs_on是一个空函数。618行，local_irq_enable函数将打开可屏蔽中断，与549行的local_irq_disable遥相呼应。621行设置全局GFP常量gfp_allowed_mask，注释上写得很清楚，中断处理模块已经成型，所以可以进行GFP分配了。继续走，623行，调用kmem_cache_init_late函数。我们在“初始化内存管理”讲解的那个mm_init()中曾经调用过一个kmem_cache_init，用于初始化内核slab分配体系，还记得吧。那么这个加了_late后缀的函数是啥意思呢，它也来自mm/slab.c：

 

void __init kmem_cache_init_late(void) {        struct kmem_cache *cachep;          /* 6) resize the head arrays to their final sizes */        mutex_lock(&cache_chain_mutex);        list_for_each_entry(cachep, &cache_chain, next)               if (enable_cpucache(cachep, GFP_NOWAIT))                      BUG();        mutex_unlock(&cache_chain_mutex);          /* Done! */        g_cpucache_up = FULL;          /* Annotate slab for lockdep -- annotate the malloc caches */        init_lock_keys();          /*         * Register a cpu startup notifier callback that initializes         * cpu_cache_get for all new cpus         */        register_cpu_notifier(&cpucache_notifier);          /*         * The reap timers are started later, with a module init call: That part         * of the kernel is not yet operational.         */ }

 

很简单，就是做几个slab分配器初始化的后续工作，其实就只做一件事，遍历cache_chain链表，把里面的所有作为slab缓存头的kmem_cache结构通过enable_cpucache函数重新计算他们的batchcount、limit和shared字段，并为NUMA体系中那些还没有初始化nodelists[node]的节点进行初始化工作。最后调用register_cpu_notifier函数，将全局变量cpucache_notifier挂到全局cpu_chain链中，具体的代码我就不去分析了。

 

5.11.2 启动console

回到start_kenel函数中，下一个函数630行的console_init()，用于初始化系统控制台结构。该函数执行后可调用printk()函数将log_buf中符合打印级别要求的系统信息打印到控制台上。还记得我们在讲printk函数的时候说过，这个函数是把字符串写到log_buf中，而启动了系统控制台后，这个log_buf中的信息就会显示在屏幕上方了。

 

void __init console_init(void) {        initcall_t *call;          /* Setup the default TTY line discipline. */        tty_ldisc_begin();          /*         * set up the console device so that later boot sequences can         * inform about problems etc..         */        call = __con_initcall_start;        while (call < __con_initcall_end) {               (*call)();               call++;        } }

 

函数虽然简单，但涉及到的东西很多。首先看到tty_ldisc_begin函数：

 

void tty_ldisc_begin(void) {        /* Setup the default TTY line discipline. */        (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY); }

 

tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY）这段代码主要的用途就是注册tty线路规程的，大家研究tty的驱动就会发现，在用户和硬件之间的tty驱动是分了三层的，其中最底层是tty驱动程序了，主要负责从硬件接受数据，和格式化上层发下来的数据后给硬件。

 

在驱动程序之上就是线路规程，他负责把从tty核心层或者tty驱动层接受的数据进行特殊的按着某个协议的格式化，就像是ppp或者蓝牙协议，然后在分发出去的。

 

在tty线路规程之上就是tty核心层。大家可参考ldd3学习一下。那么，如何初始化终端呢？这又要从编译说起了，看看我的vmlinux.lds.S中连接脚本汇编中有这段代码：

__con_initcall_start = .;

*(.con_initcall.init)

__con_initcall_end = .;

 

原来的call = __con_initcall_start就是把__con_initcall_start的虚拟地址给call，去执行在 __con_initcall_start = .;和__con_initcall_end = .;之间的con_initcall.init。这就应该是linux惯用做法，把某个实际初始化函数的指针数据是放到了con_initcall.init段中，那么是怎么放的呢？

 

在linux/init.h里面有这么一句宏定义：

#define console_initcall(fn) /

       static initcall_t __initcall_##fn /

       __used __section(.con_initcall.init) = fn

 

在我的Linux2.6.34.1的所有驱动程序里面，大约有48个文件调用了这个console_initcall宏，那么到底用的是哪个驱动程序呢？这得看看配置文件了，找到了CONFIG_SERIAL_8250，那么肯定是调用的drivers/serial/8250.c中的文件代码：

console_initcall(serial8250_console_init);

 

这回就看出来了，通过#define console_initcall(fn) /宏，调用的是serial8250_console_init函数。如果对tty的驱动程序感兴趣的同学可以好好分析一下这个代码，涉及到与显示器相连接的串口终端8250的驱动，很典型的一个串口终端驱动程序。

 

5.11.3 一些简单的函数

start_kenel的下一个函数632行的panic函数。这个函数是绝对不会被执行的，因为它是当系统发现无法继续运行下去的故障时才调用它，会导致系统中止，然后由系统显示错误号。 这里是当全局变量panic_later被设置是，才会调用。内核的panic 函数位于kernel/panic.c 文件中。

 

接下来，由于我们没有CONFIG_LOCKDEP，所以634汗的lockdep_info宏是个空宏。因为没有配置CONFIG_DEBUG_LOCKING_API_SELFTESTS，641行locking_selftest()也是个空函数。643～652的代码根据全局变量initrd_start的值打印一些信息。

 

继续走，由于我们没有配置CONFIG_CGROUP_MEM_RES_CTLR，653行的page_cgroup_init是一个空函数。654行，没有配置CONFIG_DEBUG_PAGEALLOC，debug_pagealloc_enabled也是个空函数。655行的kmemtrace_init是个待开发函数，

 

656行kmemleak_init 函数是有效取决于CONFIG_DEBUG_KMEMLEAK编译选项，我在.config文件中没找到，所以忽略。

 

657行debug_objects_mem_init函数是否有用取决于CONFIG_DEBUG_OBJECTS编译选项，我们看到，仍然是“is not set”，所以不去管它。

 

658行，idr_init_cache函数，很简单，来自lib/idr.c：

 

void __init idr_init_cache(void) {        idr_layer_cache = kmem_cache_create("idr_layer_cache",                             sizeof(struct idr_layer), 0, SLAB_PANIC, NULL); }

 

创建一个idr_layer结构的slab缓存，其头部由全局变量idr_layer_cache指向。

 

659行，setup_per_cpu_pageset：

 

void __init setup_per_cpu_pageset(void) {        struct zone *zone;        int cpu;          for_each_populated_zone(zone) {               zone->pageset = alloc_percpu(struct per_cpu_pageset);               for_each_possible_cpu(cpu) {                      struct per_cpu_pageset *pcp = per_cpu_ptr(zone->pageset, cpu);                      setup_pageset(pcp, zone_batchsize(zone));                      if (percpu_pagelist_fraction)                             setup_pagelist_highmark(pcp,                                    (zone->present_pages /                                           percpu_pagelist_fraction));               }        } }

 

函数很简单，为每个NUMA节点的zone结构的per_cpu_pageset字段分配空间，前提是如果那个zone的present_pages不为0。

 

继续走，660行，numa_policy_init函数，初始化NUMA策略：

 

/* assumes fs == KERNEL_DS */ void __init numa_policy_init(void) {        nodemask_t interleave_nodes;        unsigned long largest = 0;        int nid, prefer = 0;          policy_cache = kmem_cache_create("numa_policy",                                     sizeof(struct mempolicy),                                     0, SLAB_PANIC, NULL);          sn_cache = kmem_cache_create("shared_policy_node",                                  sizeof(struct sp_node),                                  0, SLAB_PANIC, NULL);          /*         * Set interleaving policy for system init. Interleaving is only         * enabled across suitably sized nodes (default is >= 16MB), or         * fall back to the largest node if they're all smaller.         */        nodes_clear(interleave_nodes);        for_each_node_state(nid, N_HIGH_MEMORY) {               unsigned long total_pages = node_present_pages(nid);                 /* Preserve the largest node */               if (largest < total_pages) {                      largest = total_pages;                      prefer = nid;               }                 /* Interleave this node? */               if ((total_pages << PAGE_SHIFT) >= (16 << 20))                      node_set(nid, interleave_nodes);        }          /* All too small, use the largest */        if (unlikely(nodes_empty(interleave_nodes)))               node_set(prefer, interleave_nodes);          if (do_set_mempolicy(MPOL_INTERLEAVE, 0, &interleave_nodes))               printk("numa_policy_init: interleaving failed/n"); }

 

函数很简单，通过node_set宏为每个节点的nodemask_t->bits进行设置，以满足相应的策略。回到start_kenel中，661、662行，来了，执行late_time_init函数。这个函数就是我们刚才在“初始化定时器中断”中分析过的x86_late_time_init。内核为啥要设计成这幅颜色，还得请高人们多多指点。

 

663行，sched_clock_init，来自kernel/sched_clock.c：

 

void sched_clock_init(void) {        u64 ktime_now = ktime_to_ns(ktime_get());        int cpu;          for_each_possible_cpu(cpu) {               struct sched_clock_data *scd = cpu_sdc(cpu);                 scd->tick_raw = 0;               scd->tick_gtod = ktime_now;               scd->clock = ktime_now;        }          sched_clock_running = 1; }

 

这段代码牵涉到一个每CPU变量sched_clock_data，该函数很简单，就是把每个CPU的每CPU变量sched_clock_data初始化成ktime_now。

 

5.11.4 校准CPU时钟速度

回到start_kernel中，在start_kernel的尾声有两个重要的函数，664行的calibrate_delay就是其中一个，来自init/calibrate.c：

 

122void __cpuinit calibrate_delay(void)  123{  124        unsigned long ticks, loopbit;  125        int lps_precision = LPS_PREC;  126        static bool printed;  127  128        if (preset_lpj) {  129                loops_per_jiffy = preset_lpj;  130                if (!printed)  131                        pr_info("Calibrating delay loop (skipped) "  132                                "preset value.. ");  133        } else if ((!printed) && lpj_fine) {  134                loops_per_jiffy = lpj_fine;  135                pr_info("Calibrating delay loop (skipped), "  136                        "value calculated using timer frequency.. ");  137        } else if ((loops_per_jiffy = calibrate_delay_direct()) != 0) {  138                if (!printed)  139                        pr_info("Calibrating delay using timer "  140                                "specific routine.. ");  141        } else {  142                loops_per_jiffy = (1<<12);  143  144                if (!printed)  145                        pr_info("Calibrating delay loop... ");  146                while ((loops_per_jiffy <<= 1) != 0) {  147                        /* wait for "start of" clock tick */  148                        ticks = jiffies;  149                        while (ticks == jiffies)  150                                /* nothing */;  151                        /* Go .. */  152                        ticks = jiffies;  153                        __delay(loops_per_jiffy);  154                        ticks = jiffies - ticks;  155                        if (ticks)  156                                break;  157                }  158  159                /*  160                 * Do a binary approximation to get loops_per_jiffy set to  161                 * equal one clock (up to lps_precision bits)  162                 */  163                loops_per_jiffy >>= 1;  164                loopbit = loops_per_jiffy;  165                while (lps_precision-- && (loopbit >>= 1)) {  166                        loops_per_jiffy |= loopbit;  167                        ticks = jiffies;  168                        while (ticks == jiffies)  169                                /* nothing */;  170                        ticks = jiffies;  171                        __delay(loops_per_jiffy);  172                        if (jiffies != ticks)   /* longer than 1 tick */  173                                loops_per_jiffy &= ~loopbit;  174                }  175        }  176        if (!printed)  177                pr_cont("%lu.%02lu BogoMIPS (lpj=%lu)/n",  178                        loops_per_jiffy/(500000/HZ),  179                        (loops_per_jiffy/(5000/HZ)) % 100, loops_per_jiffy);  180  181        printed = true;  182}

 

要看懂上面的代码，需要了解一些背景知识。首先，BogoMIPS值是什么意思？Bogo就是Bogus(伪)的意思，MIPS是millions of instructions per second(百万条指令每秒)的缩写。这样我们就知道了其实这个函数是linux内核中一个cpu性能测试函数。由于内核对这个数值的精度要求不高，所以内核使用了一个十分简单而有效的算法用于得到这个值。

 

这个值虽然不准确，但也足以令我们心动。如果你想了解自己机器的BogoMIPS，你可以察看/proc/cpuinfo文件中的bogomips一行。在你知道了自己cpu的BogoMIPS之后，如果你觉得不过瘾，那么让我们一起来看看calibrate_delay函数是怎么完成工作的。

 

首先，125行定义计算BogoMIPS的精度，这个值越大，则计算出的BogoMIPS越精确。我们看到LPS_PREC宏被定义成了8：

#define LPS_PREC 8

 

看到129行，loops_per_jiffy为每个时钟滴答执行一个极短的循环的次数。这个全局变量的值在我们配置了ARCH_HAS_READ_CURRENT_TIMER编译选项的情况下，由函数calibrate_delay_direct得出。很遗憾，我们并没有配置它，所以142行，loops_per_jiffy就等于1<<12，即1后面12个“0”。

 

第146至157行，是第一次计算loops_per_jiffy的值，这次计算只是一个粗略的计算，为下面的计算打好基础。

 

可以想象我们要计算loops_per_jiffy的值，可以在一个滴答的开始时，立即重复执行一个极短的循环，当一个滴答结束时，这个循环执行了多少次就是我们要求的初步的值。系统用jiffies全局变量记录了从系统开始工作到现在为止，所经过的滴答数。它会被内核自动更新——每次定时器中断发生时（每个节拍）它便加1。这行语句用于记录当前滴答数到tick变量中。

 

注意149行这是一个没有循环体得空循环，150行仅有一个“；”号。这条循环语句是通过判断tick的值与jiffies的值是否不同，来判断jiffies是否变化，即是否一个新的滴答开始了。

 

152~156行用于判断执行的延时是否超过一个滴答。一般loops_per_jiffy的初始值并不大，所以循环会逐步加大loops_per_jiffy的值，直到延时超过一个滴答。这里面的延时方法主要是153行那个__delay(loops_per_jiffy)计算：

void __delay(unsigned long loops)

{

       delay_fn(loops);

}

static void (*delay_fn)(unsigned long) = delay_loop;

static void delay_loop(unsigned long loops)

{

       asm volatile(

              "      test %0,%0     /n"

              "      jz 3f        /n"

              "      jmp 1f            /n"

              ".align 16              /n"

              "1:   jmp 2f            /n"

              ".align 16              /n"

              "2:   dec %0           /n"

              "      jnz 2b            /n"

              "3:   dec %0           /n"

              : /* we don't need output */

              :"a" (loops)

       );

}

 

我们可以看出，前一次loops_per_jiffy的值还因太小不合适时，经过一次增大，它提高了两倍，满足了循环条件，跳出循环，而这个值实在是误差太大，所以我们还要经过第二次计算。这里还要注意的是通过上面的分析，我们可以知道更加精确loops_per_jiffy的值应该在现在的值与它的一半之间。

 

所以163行，对loops_per_jiffy进行折半，这里开始就是第二次计算了。它用折半查找法在我们上面所说的范围内计算出了更精确的loops_per_jiffy的值。

 

164行定义查找范围的最小值，我把它称为起点。165行进入循环，将查找范围减半。我们看到loopbit >>= 1是在重新定义起点，起点在“原起点加loopbit减半范围”处，即新起点在原先起点与终点的中间。这时我们可以看出loops_per_jiffy在“新起点”与“新起点加减半范围（新终点）”之间。

 

第167至173行前面一致，都是等待新的滴答，执行延时。如果延时过短，说明loops_per_jiffy的值小了，将会跳过这部分，再次进入循环。它将是通过不断的折半方式来增大。如果延时过长，说明loops_per_jiffy的值大了，将起点重新返回原起点，当再次进入循环，由于范围减半，故可以达到减小的效果。

 

从这里我们可以看出它好像是个死循环，所以加入了lps_precision变量，来控制循环，即LPS_PREC越大，循环次数越多，越精确。可能这些不太好懂，总的说来，它首先将loops_per_jiffy的值定为原估算值的1/2，作为起点值(我这样称呼它)，以估算值为终点值，然后找出起点值到终点值的中间值。用上面相同的方法执行一段时间的延时循环，如果延时超过了一个tick，说明loops_per_jiffy值偏大，则仍以原起点值为起点值，以原中间值为终点值，以起点值和终点值的中间为中间值继续进行查找。如果没有超过一个tick，说明loops_per_jiffy偏小，则以原中间值为起点值，以原终点值为终点值继续查找。

　　

最后176~179行计算出BogoMIPS，并打印，至此，我们的calibrate_delay()函数就跑完了。

 

5.11.5 创建一些slab缓存

回到start_kernel中，下一个函数是pidmap_init，来自kernel/pid.c：

 

void __init pidmap_init(void) {        init_pid_ns.pidmap[0].page = kzalloc(PAGE_SIZE, GFP_KERNEL);        /* Reserve PID 0. We never call free_pidmap(0) */        set_bit(0, init_pid_ns.pidmap[0].page);        atomic_dec(&init_pid_ns.pidmap[0].nr_free);          init_pid_ns.pid_cachep = KMEM_CACHE(pid,                      SLAB_HWCACHE_ALIGN | SLAB_PANIC); }

 

该函数用于初始化pid_namespace结构的全局变量init_pid_ns，该全局变量在内核编译的时候被初始化为：

 

struct pid_namespace init_pid_ns = {        .kref = {               .refcount       = ATOMIC_INIT(2),        },        .pidmap = {               [ 0 ... PIDMAP_ENTRIES-1] = { ATOMIC_INIT(BITS_PER_PAGE), NULL }        },        .last_pid = 0,        .level = 0,        .child_reaper = &init_task, };

 

这里为它数组字段pidmap的0号元素分配一个页面，作为0号进程的pid。这里简单地讲讲为什么要在全局建立一个pid的位图。在操作系统中，每一个进程或线程都有一个唯一的编号——pid，这个号码是一个int整形字段，在缺省情况下，最大的pid号是32767。

那么，系统在分配pid号的时候，就根据这个pidmap中的值来判断，取当前系统最大pid的值从pidmap中寻找下一个空的pid。如果找不到了，就从pidmap表中的0号项开始寻找那些被释放了的进程或线程留下来的pid。只要不是系统同时有32767个进程在运行，就总能找到。

 

当然，在一些超级计算机系统上，3万多个进程限制显得有些过分，所以系统管理员可以通过往/proc/sys/kernel/pid_max 这个文件中写入一个更小的值来减小PID的上限值，使PID的上限小于32767。在64位体系结构中，系统管理员可以把PID的上限扩大到4194304。

 

接着走，666行，调用anon_vma_init，来自mm/rmap.c：

 

void __init anon_vma_init(void) {        anon_vma_cachep = kmem_cache_create("anon_vma", sizeof(struct anon_vma),                      0, SLAB_DESTROY_BY_RCU|SLAB_PANIC, anon_vma_ctor);        anon_vma_chain_cachep = KMEM_CACHE(anon_vma_chain, SLAB_PANIC); }

 

很简单，分配一个anon_vma_cachep作为anon_vma的slab缓存。这个技术是PFRA（页框回收算法）技术中的组成部分。这个技术为定位而生——快速的定位指向同一页框的所有页表项。

 

此技术中，涉及到几个关键的数据结构：anon_vma、vm_area_struct、mm_struct和page。就是通过这几个结构中的部分字段，使得线性区彼此之间形成链表，线性区与页表项之间存在联系。首先以anon_vma为链表头，形成线性区之间的双向循环链表。此循环链表中的元素就是vma_area_struct，内核将匿名线性区插入此中。而此结构中有两个字段是用于此链表的：anon_vma、anon_vma_node，前一个指向anon_vma,后一个指向链表的前一个和后一个元素。

 

而同时内核将anon_vma字段存放在page中的mapping字段中。而具体运作过程就是当进程引用的页框插入另一个进程的页表项时，内核将第二个进程的匿名线性区插入到anon_vma的双向循环链表中。而在vma_area_sturct中，还有一个字段：vm_mm指向对应的内存描述符，而内存描述符中有一个字段：pgd，存放的是页全局目录。通过这样的结构，页表项就可以从匿名页的起始线性地址得到，而该线性地址可以由线性区描述符以及页描述符的index字段得到。

 

继续走，667~670行，efi_enter_virtual_mode函数，由于我们没有配置CONFIG_EFI，所以全局变量为0，不会去执行它。671行，thread_info_cache_init函数，待开发。672行，执行一个cred_init函数，创建一个cred结构的slab缓存：

 

void __init cred_init(void) {        /* allocate a slab in which we can store credentials */        cred_jar = kmem_cache_create("cred_jar", sizeof(struct cred),                                  0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL); }

 

673行，fork_init函数，用来根据物理内存大小计算允许创建进程/线程的数量，来自fork.c：

 

void __init fork_init(unsigned long mempages) { #ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR #ifndef ARCH_MIN_TASKALIGN #define ARCH_MIN_TASKALIGN      L1_CACHE_BYTES #endif        /* create a slab on which task_structs can be allocated */        task_struct_cachep =               kmem_cache_create("task_struct", sizeof(struct task_struct),                      ARCH_MIN_TASKALIGN, SLAB_PANIC | SLAB_NOTRACK, NULL); #endif          /* do the arch specific task caches init */        arch_task_cache_init();          /*         * The default maximum number of threads is set to a safe         * value: the thread structures can take up at most half         * of memory.         */        max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);          /*         * we need to allow at least 20 threads to boot a system         */        if(max_threads < 20)               max_threads = 20;          init_task.signal->rlim[RLIMIT_NPROC].rlim_cur = max_threads/2;        init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2;        init_task.signal->rlim[RLIMIT_SIGPENDING] =               init_task.signal->rlim[RLIMIT_NPROC]; }

 

注意这里，内核中最重要的task_struct结构的slab缓存，就是在这个函数中建立的。然后调用arch_task_cache_init函数，建立thread_xstate的slab缓存：

void arch_task_cache_init(void)

{

        task_xstate_cachep =

               kmem_cache_create("task_xstate", xstate_size,

                              __alignof__(union thread_xstate),

                              SLAB_PANIC | SLAB_NOTRACK, NULL);

}

最后根据全局变量totalram_pages，即可用的页面数来计算出允许创建进程/线程的数量，赋给init_task的相关字段。

 

回到start_kernel中，下一个函数是674行的proc_caches_init，来自fork.c：

 

void __init proc_caches_init(void) {        sighand_cachep = kmem_cache_create("sighand_cache",                      sizeof(struct sighand_struct), 0,                      SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_DESTROY_BY_RCU|                      SLAB_NOTRACK, sighand_ctor);        signal_cachep = kmem_cache_create("signal_cache",                      sizeof(struct signal_struct), 0,                      SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL);        files_cachep = kmem_cache_create("files_cache",                      sizeof(struct files_struct), 0,                      SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL);        fs_cachep = kmem_cache_create("fs_cache",                      sizeof(struct fs_struct), 0,                      SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL);        mm_cachep = kmem_cache_create("mm_struct",                      sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN,                      SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL);        vm_area_cachep = KMEM_CACHE(vm_area_struct, SLAB_PANIC);        mmap_init(); }

 

几个主要的数据结构sighand_struct、signal_struct、files_struct、fs_struct、mm_struct和vm_area_struct的slab缓存的建立。随后调用mmap_init初始化每CPU计数器，也就是全局percpu_counter结构的变量vm_committed_as。

 

回到start_kernel中，675行，执行buffer_init，初始化页高速缓存：

 

void __init buffer_init(void) {        int nrpages;          bh_cachep = kmem_cache_create("buffer_head",                      sizeof(struct buffer_head), 0,                             (SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|                             SLAB_MEM_SPREAD),                             NULL);          /*         * Limit the bh occupancy to 10% of ZONE_NORMAL         */        nrpages = (nr_free_buffer_pages() * 10) / 100;        max_buffer_heads = nrpages * (PAGE_SIZE / sizeof(struct buffer_head));        hotcpu_notifier(buffer_cpu_notify, 0); }

 

著名的页高速缓存头buffer_head就是在这里被初始化的，系统建立了它的slab缓存，然后设置全局变量max_buffer_heads作为系统能最大限度使用的高速缓存页面的数量。最后把buffer_cpu_notify加入到通知链中。有关页高速缓存的相关内容，请访问博客“磁盘高速缓存”http://blog.csdn.net/yunsongice/archive/2010/08/23/5833154.aspx。

 

start_kernel的676行，key_init函数：

 

void __init key_init(void) {        /* allocate a slab in which we can store keys */        key_jar = kmem_cache_create("key_jar", sizeof(struct key),                      0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);          /* add the special key types */        list_add_tail(&key_type_keyring.link, &key_types_list);        list_add_tail(&key_type_dead.link, &key_types_list);        list_add_tail(&key_type_user.link, &key_types_list);          /* record the root user tracking */        rb_link_node(&root_key_user.node,                    NULL,                    &key_user_tree.rb_node);          rb_insert_color(&root_key_user.node,                      &key_user_tree);   }

 

很简单，建立一个key结构的slab缓存，并初始化一些全局变量，然后建立一个key_user_tree为根节点的红黑树。

 

start_kernel的677行，security_init函数。这个函数跟上一个函数一样，都是系统安全相关的内容，感兴趣的同学可以好好研究一下。