内核入口

接着往下走，下一步看到了此函数:

lockdep_init();

lockdep_init 初始化 lock validator . 其实现是相当简单的，它只是初始化了两个哈希表 list_head 并设置 lockdep_initialized 全局变量为 1

关于自旋锁 spinlock 以及 互斥锁mutex 如何获取

请参考链接 https://zh.wikipedia.org/wiki/%E8%87%AA%E6%97%8B%E9%94%81
https://zh.wikipedia.org/wiki/%E4%BA%92%E6%96%A5%E9%94%81 

下一个函数是 set_task_stack_end_magic ，参数为 init_task 初始化进程(任务) 数据结构。这个函数会为栈底设置一个魔术数字 STACK_END_MAGIC : 0x57AC6E9D 来防止栈溢出攻击

struct task_struct init_task = INIT_TASK(init_task);

task_struct 存储了进程的所有相关信息，可以查看调度相关数据结构定义头文件 include/linux/sched.h

因为它很庞大，这本书并不会去介绍

现在 task_struct已经包含了超过100个字段！

虽然不会在这本书中看到关于task_struct的解释，但是会经常使用它

因为它是介绍在Linux内核进程的基本知识，接下来将描述这个结构中字段的一些含义

可以查看 宏INIT_TASK 的初始化流程。这个宏指令来自于 include/linux/init_task.h 这里只是设置和初始化了第一个进程来(0号进程)的值。例如：

• 初始化进程状态为 zero 或者 runnable. 一个可运行进程即为等待CPU去运行
• 初始化仅存的标志位 PF_KTHREAD: 意思为 内核线程
• 一个可运行的任务列表
• 进程地址空间
• 初始化进程堆栈 &init_thread_info:

  • init_thread_union.thread_info 和 init_thread_union 使用union thread_union

    • thread_union 包含了 thread_info进程信息以及进程栈：

    union thread_union {
                    struct thread_info thread_info;
                    unsigned long stack[THREAD_SIZE/sizeof(long)];
    };
    

    每个进程都有其自己的堆栈，x86_64架构的CPU一般支持的页表是16KB or 4个页框大小
    
    注意：stack变量被定义为数据并且类型是unsigned long
         thread_union代表一个联合体union而不是结构体
    

    • thread_info 定义如下：

      struct thread_info {
              struct task_struct      *task;
              struct exec_domain      *exec_domain;
              __u32                   flags; 
              __u32                   status;
              __u32                   cpu;
              int                     saved_preempt_count;
              mm_segment_t            addr_limit;
              struct restart_block    restart_block;
              void __user             *sysenter_return;
              unsigned int            sig_on_uaccess_error:1;
              unsigned int            uaccess_err:1;
      };
      

      thread_info结构包含了特定体系架构相关的线程信息，此结构占用52个字节
      
      在X86_64架构上内核栈是逆生成而thread_union.thread_info结构则是正生长
      
      进程进程栈是16KB并且thread_info是在栈底，因此可以使用的是：16KB - 52 bytes = 16332 bytes
      

  • 用一张图来描述栈内存空间。 如下图所示:

    e+-----------------------+
    |                       |
    |                       |
    |        stack          |
    |                       |
    |_______________________|
    |          |            |
    |          |            |
    |          |            |
    |__________↓____________|             +--------------------+
    |                       |             |                    |
    |      thread_info      |<----------->|     task_struct    |
    |                       |             |                    |
    +-----------------------+             +--------------------+
    

现在回到set_task_stack_end_magic函数，这个函数被定义在 kernel/fork.c 功能为设置 init 进程堆栈以检测堆栈溢出 ：

void set_task_stack_end_magic(struct task_struct *tsk)
{
                unsigned long *stackend;
                stackend = end_of_stack(tsk);
                *stackend = STACK_END_MAGIC; /* for overflow detection */
}

先通过 end_of_stack 函数获取堆栈并赋给 task_struct 。因为学习的是x86架构的初始化，堆栈是逆生成，所以堆栈底部为：

(unsigned long *)(task_thread_info(p) + 1);

在进程的栈底，写入STACK_END_MAGIC这个值

下一个函数是 smp_setup_processor_id .此函数在x86_64架构上是空函数：

void __init __weak smp_setup_processor_id(void)
{
}

在此架构上没有实现此函数，但在别的体系架构的实现可以参考 arm64

debug_object_early_init 函数的执行几乎和lockdep_init是一样的，但是填充的哈希对象是调试相关

task_struct->canary 的值利用了GCC特性

但是此特性需要先使能内核CONFIG_CC_STACKPROTECTOR宏后才可以使用，否则什么也不做

boot_init_stack_canary 基于随机数和随机池产生 TSC :

get_random_bytes(&canary, sizeof(canary));
tsc = __native_read_tsc();
canary += tsc + (tsc << 32UL);

给当前字段的 stack_canary 字段赋值：

current->stack_canary = canary;

然后将此值写入IRQ 堆栈的顶部:

this_cpu_write(irq_stack_union.stack_canary, canary);

关于IRQ的章节这里也不会详细剖析

canary被设置后, 关闭本地中断 interrupts for current CPU 使用 local_irq_disable 函数，展开后原型为 arch_local_irq_disable 函数 include/linux/percpu-defs.h:

static inline notrace void arch_local_irq_disable(void)
{
        native_irq_disable();
}

在内核text和data段中保留内存用来初始化initrd

暂时不去了解initrd的详细信息，仅仅只需要知道根文件系统就是通过这种方式来进行初始化

这就是 early_reserve_initrd 函数的工作，此函数获取 RAM DISK的基地址 、 RAM DISK的大小 以及 RAM DISK的结束地址 ：

u64 ramdisk_image = get_ramdisk_image();
u64 ramdisk_size  = get_ramdisk_size();
u64 ramdisk_end   = PAGE_ALIGN(ramdisk_image + ramdisk_size);

如果阅读过前面Linux启动过程 ，就知道所有的这些参数都来自于boot_params

boot_params在boot期间已经被赋值，包含了一下几个字段用来描述RAM DISK：

Field name:	ramdisk_image
Type:		write (obligatory)
Offset/size:	0x218/4
Protocol:	2.00+

  The 32-bit linear address of the initial ramdisk or ramfs.  Leave at
  zero if there is no initial ramdisk/ramfs.

具体查看 get_ramdisk_image :

static u64 __init get_ramdisk_image(void)
{
        u64 ramdisk_image = boot_params.hdr.ramdisk_image;

        ramdisk_image |= (u64)boot_params.ext_ramdisk_image << 32;

        return ramdisk_image;
}

关于32位的ramdisk的地址，可以阅读此部分内容来获取zero-page.txt:

0C0/004	ALL	ext_ramdisk_image ramdisk_image high 32bits

获取64位的ramdisk原理一样，为此可以检查bootloader 提供的ramdisk信息：

if (!boot_params.hdr.type_of_loader ||
    !ramdisk_image || !ramdisk_size)
                return;

校验成功后保留内存块，并将ramdisk传输到最终的内存地址，然后进行初始化：

memblock_reserve(ramdisk_image, ramdisk_end - ramdisk_image);