linux内核启动分析（二）

我们前面看了start_kernel前的汇编进行的初始化工作，现在开始看start_kernel函数了：

1. set_task_stack_end_magic

void set_task_stack_end_magic(struct task_struct *tsk)
{unsigned long *stackend;stackend = end_of_stack(tsk);//获取内核栈末尾地址*stackend = STACK_END_MAGIC;//设置为魔数，//在每次栈空间被使用时，内核都会检查该位置的值是否保持不变//如果发现变化，就会发出栈溢出的警报。#define task_stack_end_corrupted(task) \(*(end_of_stack(task)) != STACK_END_MAGIC)
}

set_task_stack_end_magic函数就做了一件事，获取内核栈的末尾地址，然后给这个地址赋值STACK_END_MAGIC。然后linux内核是使用task_stack_end_corrupted这个宏判断内核是否栈溢出的。linux内核会在cpu睡眠的时候检查当前栈是否发生溢出。如果开启了schedule debug则会在schedule的时候检查上一个进程的栈是否发生溢出。如果我们真的担心这个问题，最好的做法是在内核的启动参数，一般是grub中添加stacktrace，那么开启内核的函数调用堆栈追踪功能，同事会检查堆栈是否溢出。

2.smp_setup_processor_id

void __init smp_setup_processor_id(void)
{//读取MPIDR_EL1寄存器，并且只保留4个等级表示该core属于哪个cluse等信息u64 mpidr = read_cpuid_mpidr() & MPIDR_HWID_BITMASK;set_cpu_logical_map(0, mpidr);//把core信息写入__cpu_logical_map/** clear __my_cpu_offset on boot CPU to avoid hang caused by* using percpu variable early, for example, lockdep will* access percpu variable inside lock_release*///tpidr_el1存放当前cpu的线程IDset_my_cpu_offset(0);//初始化0到对应cpu的tpidr_el1和tpidr_el2寄存器pr_info("Booting Linux on physical CPU 0x%010lx [0x%08x]\n",(unsigned long)mpidr, read_cpuid_id());
}

smp_setup_processor_id函数主要做了两个事情：

1. 读取MPIDR_EL1，把该寄存器的4个等级的aff提取出来，写入该cpu号为下标的__cpu_logical_map数组中。这4组aff值在每个core中是唯一的，加起来可以表示core在整个soc的位置。aff0表示一个core中的第几个线程，因为有可能使用超线程技术，一个core中有两个线程；aff1表示core在cluster中的第几个core；aff2表示这是在第几个cluster中。这个值是soc厂商写死的，用于表示core的信息。
2. 初始化tpidr_el1和tpidr_el2寄存器为0。以前我一直以为它表示当前cpu处于0号进程，当时认为这个寄存器是用来存放当前cpu正在处理的进程的进程号的，加速cpu找到current这个task_struct结构体。 现在看了代码才知道，这个寄存器是存放每cpu的offs值的，用于快速找到每cpu变量所在的内存。

3. debug_objects_early_init

我们没有开启CONFIG_DEBUG_OBJECTS，是个空函数。

4. cgroup_init_early

int __init cgroup_init_early(void)
{static struct cgroup_fs_context __initdata ctx;struct cgroup_subsys *ss;int i;ctx.root = &cgrp_dfl_root;init_cgroup_root(&ctx);//注册和初始化根控制组cgrp_dfl_root.cgrp.self.flags |= CSS_NO_REF;//初始化init_task.cgroups，这个RCU指针结构体，看看他的定义就懂了//struct css_set __rcu		*cgroups;RCU_INIT_POINTER(init_task.cgroups, &init_css_set);//组装好基本的控制组框架for_each_subsys(ss, i) {//遍历所有启用的cgroup子系统，他们存放在cgroup_subsys数组中WARN(!ss->css_alloc || !ss->css_free || ss->name || ss->id,"invalid cgroup_subsys %d:%s css_alloc=%p css_free=%p id:name=%d:%s\n",i, cgroup_subsys_name[i], ss->css_alloc, ss->css_free,ss->id, ss->name);WARN(strlen(cgroup_subsys_name[i]) > MAX_CGROUP_TYPE_NAMELEN,"cgroup_subsys_name %s too long\n", cgroup_subsys_name[i]);ss->id = i;//设置IDss->name = cgroup_subsys_name[i];//设置cgroup名字if (!ss->legacy_name)ss->legacy_name = cgroup_subsys_name[i];//设置legacy_nameif (ss->early_init)cgroup_init_subsys(ss, true);//cgroup的某一个子系统}return 0;
}

我们cgroup开启了cpuset、cpu、cpuacct、io、memory、devices、perf_event、hugetlb、pids这几个子系统。
cgroup_init_early函数主要做了几件：

1. 调用函数init_cgroup_root注册和初始化根控制组；
2. 初始化init_task.cgroups，这个RCU类型的指针；
3. 遍历所有启用的cgroup子系统，初始化他们，主要是使用cgroup_init_subsys函数初始化子系统。

4.1 init_cgroup_root

void init_cgroup_root(struct cgroup_fs_context *ctx)
{struct cgroup_root *root = ctx->root;struct cgroup *cgrp = &root->cgrp;INIT_LIST_HEAD(&root->root_list);//初始化cgroup_root的链表atomic_set(&root->nr_cgrps, 1);//设置cgroup的数量为1cgrp->root = root;init_cgroup_housekeeping(cgrp);//初始化根cgroup的后勤工作//初始化root的flags、release_agent_path、name、cgrp。root->flags = ctx->flags;if (ctx->release_agent)strscpy(root->release_agent_path, ctx->release_agent, PATH_MAX);if (ctx->name)strscpy(root->name, ctx->name, MAX_CGROUP_ROOT_NAMELEN);if (ctx->cpuset_clone_children)set_bit(CGRP_CPUSET_CLONE_CHILDREN, &root->cgrp.flags);
}

init_cgroup_root函数主要做了一下工作：

1. 初始化cgroup_root的链表，设置cgroup的数量为1；
2. 调用函数init_cgroup_housekeeping初始化根cgroup的后勤工作；
3. 初始化root的flags、release_agent_path、name、cgrp。

4.1.1 init_cgroup_housekeeping

static void init_cgroup_housekeeping(struct cgroup *cgrp)
{struct cgroup_subsys *ss;int ssid;INIT_LIST_HEAD(&cgrp->self.sibling);//初始化存放兄弟cgroup的链表INIT_LIST_HEAD(&cgrp->self.children);//初始化存放子cgroup的链表INIT_LIST_HEAD(&cgrp->cset_links);//初始化指向cgrp_cset_links的列表INIT_LIST_HEAD(&cgrp->pidlists);//初始化存放进程pid的链表mutex_init(&cgrp->pidlist_mutex);//初始化保护pidlists的互斥锁//初始化cgrp的其他成员参数cgrp->self.cgroup = cgrp;cgrp->self.flags |= CSS_ONLINE;cgrp->dom_cgrp = cgrp;cgrp->max_descendants = INT_MAX;cgrp->max_depth = INT_MAX;INIT_LIST_HEAD(&cgrp->rstat_css_list);prev_cputime_init(&cgrp->prev_cputime);//空函数for_each_subsys(ss, ssid)INIT_LIST_HEAD(&cgrp->e_csets[ssid]);init_waitqueue_head(&cgrp->offline_waitq);//初始化工作队列，用于release的时候调用cgroup1_release_agent函数启动一个用户态程序INIT_WORK(&cgrp->release_agent_work, cgroup1_release_agent);
}

init_cgroup_housekeeping主要是做了以下工作：

1. 初始化存放兄弟cgroup的链表self.sibling
2. 初始化存放子cgroup的链表self.children
3. 初始化指向cgrp_cset_links的列表cgrp->cset_links
4. 初始化存放进程pid的链表cgrp->pidlists
5. 初始化保护pidlists的互斥锁cgrp->pidlist_mutex
6. 初始化cgrp的其他成员参数

4.2 cgroup_init_subsys

因为启动阶段，ss->early_init为0，cgroup_init_subsys没有执行，先不看。

5. local_irq_disable

#define local_irq_disable()				\do {						\bool was_disabled = raw_irqs_disabled();\raw_local_irq_disable();		\if (!was_disabled)			\trace_hardirqs_off();		\} while (0)

local_irq_disable这个宏主要做了3个工作：

1. 调用函数raw_irqs_disabled读取irq的状态；
2. 调用函数raw_local_irq_disable关中断；
3. 判断步骤一获取到的状态是否关闭，如果还没有关闭，就执行trace_hardirqs_off函数进行trace。

5.1 raw_irqs_disabled

#define raw_irqs_disabled()		(arch_irqs_disabled())static inline int arch_irqs_disabled(void)
{return arch_irqs_disabled_flags(arch_local_save_flags());
}static inline unsigned long arch_local_save_flags(void)
{unsigned long flags;asm volatile(ALTERNATIVE("mrs	%0, daif",__mrs_s("%0", SYS_ICC_PMR_EL1),ARM64_HAS_IRQ_PRIO_MASKING): "=&r" (flags):: "memory");return flags;
}static inline int arch_irqs_disabled_flags(unsigned long flags)
{int res;asm volatile(ALTERNATIVE("and	%w0, %w1, #" __stringify(PSR_I_BIT),"eor	%w0, %w1, #" __stringify(GIC_PRIO_IRQON),ARM64_HAS_IRQ_PRIO_MASKING): "=&r" (res): "r" ((int) flags): "memory");return res;
}

raw_irqs_disabled主要做了：

1. 调用函数arch_local_save_flags获取daif，其中表示了cpu的irq情况，
2. 调用函数arch_irqs_disabled_flags对步骤一的返回值进行处理，只保留irq的bit。

5.2 raw_local_irq_disable

#define raw_local_irq_disable()		arch_local_irq_disable()static inline void arch_local_irq_disable(void)
{if (system_has_prio_mask_debugging()) {u32 pmr = read_sysreg_s(SYS_ICC_PMR_EL1);WARN_ON_ONCE(pmr != GIC_PRIO_IRQON && pmr != GIC_PRIO_IRQOFF);}asm volatile(ALTERNATIVE("msr	daifset, #2		// arch_local_irq_disable",__msr_s(SYS_ICC_PMR_EL1, "%0"),ARM64_HAS_IRQ_PRIO_MASKING):: "r" ((unsigned long) GIC_PRIO_IRQOFF): "memory");
}

raw_local_irq_disable主要是执行了汇编 “msr daifset, #2” ，从而达到关闭irq。

5.3 trace_hardirqs_off

void trace_hardirqs_off(void)
{lockdep_hardirqs_off(CALLER_ADDR0);if (!this_cpu_read(tracing_irq_cpu)) {this_cpu_write(tracing_irq_cpu, 1);tracer_hardirqs_off(CALLER_ADDR0, CALLER_ADDR1);if (!in_nmi())trace_irq_disable_rcuidle(CALLER_ADDR0, CALLER_ADDR1);}
}

这个函数追进去看不太懂，只知道这是ftrace的东西。

6. boot_cpu_init

void __init boot_cpu_init(void)
{int cpu = smp_processor_id();/* Mark the boot cpu "present", "online" etc for SMP and UP case */set_cpu_online(cpu, true);//记录当前cpu为onlineset_cpu_active(cpu, true);//记录当前cpu为activeset_cpu_present(cpu, true);//记录当前cpu为presentset_cpu_possible(cpu, true);//记录当前cpu为possible#ifdef CONFIG_SMP__boot_cpu_id = cpu;//记录引导的cpu ID
#endif
}

boot_cpu_init主要是设置当前cpu的状态，这些状态保存在全局变量__cpu_online_mask、__cpu_active_mask、__cpu_present_mask、__cpu_possible_mask中。

7. page_address_init

void __init page_address_init(void)
{int i;for (i = 0; i < ARRAY_SIZE(page_address_htable); i++) {INIT_LIST_HEAD(&page_address_htable[i].lh);spin_lock_init(&page_address_htable[i].lock);}
}static struct page_address_slot {struct list_head lh;			/* List of page_address_maps */spinlock_t lock;			/* Protect this bucket's list */
} ____cacheline_aligned_in_smp page_address_htable[1<<PA_HASH_ORDER];struct page_address_map {struct page *page;void *virtual;struct list_head list;
};static struct page_address_map page_address_maps[LAST_PKMAP];

page_address_init函数只有一个作用就是初始化page_address_htable数组，这个数组是一个哈希桶，这个列表存放的是struct page_address_map结构体，看到这个结构体我么就知道这是一个page到虚拟地址的映射关系，也就是说我们经常挺熟的反向映射。

8. early_security_init

不太能看懂，后续补，先学习一下。