Linux内核构建过程简析

引言

本文不会介绍如何在你的机器上构建和安装自定义 Linux 内核 —— 如果你需要这方面的帮助，可以找到许多相关资源（参考：Linux 内核官方构建指南、Ubuntu 内核编译教程）。相反，我们将深入探讨当你在 Linux 内核源代码根目录执行make命令时，背后究竟发生了什么。

当我开始研究 Linux 内核源代码时，第一个打开的文件就是 Makefile，它当时让我望而生畏：）。在我撰写这部分内容时，该 Makefile 包含 1591 行代码，对应的内核版本是 4.2.0-rc3。

这个 Makefile 是 Linux 内核源代码中的顶层 Makefile，内核构建过程正是从这里启动。诚然，它的规模十分庞大，而且如果你阅读过 Linux 内核源代码，可能会注意到所有包含源代码的目录都有自己的 Makefile。显然，我们无法逐一描述每个源文件的编译和链接过程，因此仅探讨标准编译场景。本文不会涉及内核文档构建、源代码清理、标签生成、交叉编译相关内容等（交叉编译细节可参考：内核交叉编译官方文档）。我们将从使用标准内核配置文件执行make命令开始，一直讲到 bzImage 镜像的构建完成。

如果你已经熟悉 make 工具会更好（make 工具详细用法可参考：GNU Make 官方手册），但无论如何，我都会尽力解释每一段代码的作用。

那么，让我们开始吧。

内核编译前的准备工作

在启动内核编译之前，需要完成多项准备工作。核心任务包括确定编译类型、配置编译参数、解析传递给make命令的命令行参数等。接下来，让我们深入分析 Linux 内核的顶层 Makefile。

Linux 内核的顶层 Makefile 负责构建两大核心产物：vmlinux（常驻内核镜像）和模块（所有模块文件）。该 Makefile 以定义以下变量开篇：

VERSION = 4

PATCHLEVEL = 2

SUBLEVEL = 0

EXTRAVERSION = -rc3

NAME = Hurr durr I'm a sheep

这些变量定义了当前 Linux 内核的版本信息，并在多个场景中被使用 —— 例如在同一个 Makefile 中构建KERNELVERSION变量：

KERNELVERSION = \$(VERSION)\$(if \$(PATCHLEVEL),.\$(PATCHLEVEL)\$(if \$(SUBLEVEL),.\$(SUBLEVEL)))\$(EXTRAVERSION)

随后可以看到几组ifeq条件判断，用于检查传递给make命令的部分参数。Linux 内核的 Makefile 提供了一个特殊的make help目标，用于打印所有可用目标以及可传递给make命令的部分参数。例如：make V=1表示 verbose 构建（详细输出模式）。第一组ifeq判断是否传递了V=n选项：

ifeq ("\$(origin V)", "command line")

KBUILD\_VERBOSE = \$(V)

endif

ifndef KBUILD\_VERBOSE

KBUILD\_VERBOSE = 0

endif

ifeq (\$(KBUILD\_VERBOSE),1)

quiet =

Q =

else

quiet=quiet\_

Q = @

endif

export quiet Q KBUILD\_VERBOSE

如果传递了该选项，就将KBUILD_VERBOSE变量设置为V选项的值；否则默认设置为 0。接着根据KBUILD_VERBOSE的值配置quiet和Q变量：@符号用于抑制命令输出，若命令前添加该符号，输出会显示为CC scripts/mod/empty.o，而非完整的Compiling .... scripts/mod/empty.o。最后导出所有这些变量供后续使用。

下一组ifeq判断是否传递了O=/dir选项，该选项用于指定所有输出文件的存放目录：

ifeq (\$(KBUILD\_SRC),)

ifeq ("\$(origin O)", "command line")

KBUILD\_OUTPUT := \$(O)

endif

ifneq (\$(KBUILD\_OUTPUT),)

saved-output := \$(KBUILD\_OUTPUT)

KBUILD\_OUTPUT := \$(shell mkdir -p \$(KBUILD\_OUTPUT) && cd \$(KBUILD\_OUTPUT) && /bin/pwd)

\$(if \$(KBUILD\_OUTPUT),, \$(error failed to create output directory "\$(saved-output)"))

sub-make: FORCE

\$(Q)\$(MAKE) -C \$(KBUILD\_OUTPUT) KBUILD\_SRC=\$(CURDIR) -f \$(CURDIR)/Makefile \$(filter-out \_all sub-make,\$(MAKECMDGOALS))

skip-makefile := 1

endif # ifneq (\$(KBUILD\_OUTPUT),)

endif # ifeq (\$(KBUILD\_SRC),)

首先检查KBUILD_SRC变量（表示内核源代码的顶层目录，首次执行 Makefile 时为空）。若传递了O选项，则将KBUILD_OUTPUT变量设置为该选项的值。如果KBUILD_OUTPUT已设置，将执行以下操作：

1. 1. 把KBUILD_OUTPUT的值暂存到saved-output变量；
2. 2. 尝试创建指定的输出目录；
3. 3. 验证目录是否创建成功，失败则输出错误信息；
4. 4. 若自定义输出目录创建成功，切换到该目录重新执行make命令（通过-C选项指定目录）。

接下来的ifeq判断是否传递了C或M选项：

ifeq ("\$(origin C)", "command line")

KBUILD\_CHECKSRC = \$(C)

endif

ifndef KBUILD\_CHECKSRC

KBUILD\_CHECKSRC = 0

endif

ifeq ("\$(origin M)", "command line")

KBUILD\_EXTMOD := \$(M)

endif

C选项指定使用$CHECK环境变量提供的工具（默认是 sparse，sparse 工具详情可参考：sparse 官方仓库）检查所有 C 源代码；M选项用于构建外部模块（外部模块构建指南可参考：内核外部模块开发文档，本文不涉及此场景）。

随后检查KBUILD_SRC变量是否已设置，若未设置则将srctree变量设为当前目录（.）：

ifeq (\$(KBUILD\_SRC),)

srctree := .

endif

objtree := .

src := \$(srctree)

obj := \$(objtree)

export srctree objtree VPATH

这表明内核源代码树位于执行make命令的当前目录，同时将objtree等变量也设置为该目录并导出。

下一步是获取SUBARCH变量的值，该变量表示底层硬件架构：

SUBARCH := \$(shell uname -m | sed -e s/i.86/x86/ -e s/x86\_64/x86/ \\

-e s/sun4u/sparc64/ \\

-e s/arm.\*/arm/ -e s/sa110/arm/ \\

-e s/s390x/s390/ -e s/parisc64/parisc/ \\

-e s/ppc.\*/powerpc/ -e s/mips.\*/mips/ \\

-e s/sh\[234].\*/sh/ -e s/aarch64.\*/arm64/ )

通过执行uname工具获取机器、操作系统和架构信息（uname 工具用法可参考：GNU Coreutils uname 文档），然后解析输出结果并赋值给SUBARCH变量。有了SUBARCH之后，继续设置SRCARCH变量（指定特定架构的目录）和hdr-arch变量（指定头文件目录）：

ifeq (\$(ARCH),i386)

SRCARCH := x86

endif

ifeq (\$(ARCH),x86\_64)

SRCARCH := x86

endif

hdr-arch := \$(SRCARCH)

注意：ARCH是SUBARCH的别名。

接下来设置KCONFIG_CONFIG变量，该变量表示内核配置文件的路径，默认值为.config（内核配置工具使用指南可参考：内核配置文档）：

KCONFIG\_CONFIG ?= .config

export KCONFIG\_CONFIG

同时指定内核编译过程中使用的 shell：

CONFIG\_SHELL := \$(shell if \[ -x "\$\$BASH" ]; then echo \$\$BASH; \\

else if \[ -x /bin/bash ]; then echo /bin/bash; \\

else echo sh; fi ; fi)

下一组变量与 Linux 内核编译使用的编译器相关，包括主机 C 编译器、C++ 编译器及其编译选项：

HOSTCC = gcc

HOSTCXX = g++

HOSTCFLAGS = -Wall -Wmissing-prototypes -Wstrict-prototypes -O2 -fomit-frame-pointer -std=gnu89

HOSTCXXFLAGS = -O2

这里需要说明：CC是内核编译使用的目标编译器，而HOSTCC用于编译一组主机程序（后续会详细介绍）。gcc 编译器详细参数可参考：GCC 官方文档。

随后定义KBUILD_MODULES和KBUILD_BUILTIN变量，用于确定编译内容（模块、内核或两者皆有）：

KBUILD\_MODULES :=

KBUILD\_BUILTIN := 1

ifeq (\$(MAKECMDGOALS),modules)

KBUILD\_BUILTIN := \$(if \$(CONFIG\_MODVERSIONS),1)

endif

若仅传递modules目标给make命令，KBUILD_BUILTIN的值将取决于内核配置参数CONFIG_MODVERSIONS（模块版本控制详情可参考：内核模块版本文档）。

下一步是包含 kbuild 文件：

include scripts/Kbuild.include

Kbuild（内核构建系统）是用于管理内核及其模块构建的专用基础设施，其文件语法与 Makefile 一致。scripts/Kbuild.include文件为 kbuild 系统提供了一些通用定义（Kbuild 系统详情可参考：Kbuild 官方文档）。

包含该文件后，将定义与内核和模块编译相关的各类工具变量（如链接器、编译器、binutils 工具集等，binutils 工具集详情可参考：GNU Binutils 文档）：

AS      = \$(CROSS\_COMPILE)as

LD      = \$(CROSS\_COMPILE)ld

CC      = \$(CROSS\_COMPILE)gcc

CPP     = \$(CC) -E

AR      = \$(CROSS\_COMPILE)ar

NM      = \$(CROSS\_COMPILE)nm

STRIP   = \$(CROSS\_COMPILE)strip

OBJCOPY = \$(CROSS\_COMPILE)objcopy

OBJDUMP = \$(CROSS\_COMPILE)objdump

AWK     = awk

接着定义USERINCLUDE和LINUXINCLUDE变量，分别指定用户空间头文件目录和内核空间头文件目录的路径：

USERINCLUDE := \\

\$(srctree)/arch/\$(hdr-arch)/include/uapi \\

-Iarch/\$(hdr-arch)/include/generated/uapi \\

\$(srctree)/include/uapi \\

-Iinclude/generated/uapi \\

-include \$(srctree)/include/linux/kconfig.h

LINUXINCLUDE := \\

\$(srctree)/arch/\$(hdr-arch)/include \\

…

以及 C 编译器的标准编译选项：

KBUILD\_CFLAGS := -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs \\

-fno-strict-aliasing -fno-common \\

-Werror-implicit-function-declaration \\

-Wno-format-security \\

-std=gnu89

注意：这些并非最终的编译选项，其他 Makefile（如架构相关的 kbuild 文件）可能会对其进行修改。

完成所有变量定义后，将导出这些变量供其他 Makefile 使用。RCS_FIND_IGNORE和RCS_TAR_IGNORE变量指定版本控制系统中需要忽略的文件（常见版本控制系统使用指南可参考：Git 官方文档、SVN 官方文档）：

export RCS\_FIND\_IGNORE := \\( -name SCCS -o -name BitKeeper -o -name .svn -o \\

-name CVS -o -name .pc -o -name .hg -o -name .git \\) \\

-prune -o

export RCS\_TAR\_IGNORE := --exclude SCCS --exclude BitKeeper --exclude .svn \\

\--exclude CVS --exclude .pc --exclude .hg --exclude .git

至此，所有准备工作全部完成，下一步将进入内核构建阶段。

内核构建核心流程

完成所有准备工作后，顶层 Makefile 的下一部分将聚焦内核构建。在此之前，make命令不会向终端输出任何信息，而从现在开始，编译的第一步即将启动。我们需要查看 Linux 内核顶层 Makefile 的第 598 行，找到vmlinux目标：

all: vmlinux

include arch/\$(SRCARCH)/Makefile

无需担心我们跳过了export RCS_FIND_IGNORE与all: vmlinux之间的大量代码 —— 这部分负责处理make *.config相关目标，正如本文开头所述，我们仅关注内核的通用构建流程。

all是默认目标（当命令行未指定目标时执行）。这里会包含架构相关的 Makefile（本文以 x86 架构为例，即arch/x86/Makefile），后续流程将基于该 Makefile 继续。可以看到，all目标依赖于vmlinux目标，该目标在顶层 Makefile 的后续部分定义：

vmlinux: scripts/link-vmlinux.sh \$(vmlinux-deps) FORCE

vmlinux是静态链接的可执行文件格式的 Linux 内核。scripts/``link-vmlinux.sh脚本负责将各个编译后的子系统链接合并为vmlinux（链接脚本详情可参考：ld 链接器文档）。第二个依赖项vmlinux-deps的定义如下：

vmlinux-deps := \$(KBUILD\_LDS) \$(KBUILD\_VMLINUX\_INIT) \$(KBUILD\_VMLINUX\_MAIN)

它包含 Linux 内核各个顶层目录生成的built-in.o文件。后续遍历内核所有目录时，Kbuild 会编译所有$(obj-y)文件，然后调用$(LD) -r将这些文件合并为一个built-in.o文件。此时vmlinux-deps尚未生成，因此vmlinux目标暂不执行。在我的环境中，vmlinux-deps包含以下文件：

arch/x86/kernel/vmlinux.lds arch/x86/kernel/head\_64.o

arch/x86/kernel/head64.o arch/x86/kernel/head.o

init/built-in.o usr/built-in.o

fs/built-in.o block/built-in.o

lib/lib.a lib/built-in.o

kernel/built-in.o arch/x86/power/built-in.o

arch/x86/built-in.o mm/built-in.o

ipc/built-in.o sound/built-in.o

security/built-in.o crypto/built-in.o

lib/lib.a arch/x86/lib/lib.a

arch/x86/lib/built-in.o drivers/built-in.o

firmware/built-in.o arch/x86/pci/built-in.o

arch/x86/video/built-in.o net/built-in.o

接下来执行的目标如下：

\$(sort \$(vmlinux-deps)): \$(vmlinux-dirs) ;

\$(vmlinux-dirs): prepare scripts

\$(Q)\$(MAKE) \$(build)=\$@

vmlinux-dirs依赖于prepare和scripts两个目标。prepare在顶层 Makefile 中定义，包含三个准备阶段：

prepare: prepare0

prepare0: archprepare FORCE

\$(Q)\$(MAKE) \$(build)=.

archprepare: archheaders archscripts prepare1 scripts\_basic

prepare1: prepare2 \$(version\_h) include/generated/utsrelease.h include/config/auto.conf

\$(cmd\_crmodverdir)

prepare2: prepare3 outputmakefile asm-generic

第一个阶段prepare0会展开为archprepare，而archprepare又包含archheaders和archscripts（定义在 x86_64 架构专用的 Makefile 中）。让我们深入分析该 Makefile：x86_64 架构的 Makefile 首先定义与架构相关的配置变量（如 defconfig，defconfig 详情可参考：内核 defconfig 文档），随后定义 16 位代码的编译选项、BITS变量（i386 架构为 32，x86_64 架构为 64）、汇编源代码的编译选项、链接器选项等（所有定义可在arch/x86/Makefile中查看）。

该 Makefile 中的第一个目标archheaders用于生成系统调用表（系统调用表详情可参考：Linux 系统调用文档）：

archheaders:

\$(Q)\$(MAKE) \$(build)=arch/x86/entry/syscalls all

第二个目标archscripts定义如下：

archscripts: scripts\_basic

\$(Q)\$(MAKE) \$(build)=arch/x86/tools relocs

它依赖于顶层 Makefile 中的scripts_basic目标。首先执行scripts_basic目标，该目标会对scripts/basic目录的 Makefile 执行make命令：

scripts\_basic:

\$(Q)\$(MAKE) \$(build)=scripts/basic

scripts/basic/Makefile包含两个主机程序的编译目标：fixdep和bin2c：

hostprogs-y := fixdep

hostprogs-\$(CONFIG\_BUILD\_BIN2C) += bin2c

always := \$(hostprogs-y)

\$(addprefix \$(obj)/,\$(filter-out fixdep,\$(always))): \$(obj)/fixdep

• • fixdep：优化 gcc 生成的依赖列表，告知make何时需要重新编译源文件；
• • bin2c：依赖于内核配置选项CONFIG_BUILD_BIN2C，是一个小型 C 程序，可将标准输入的二进制文件转换为 C 语言头文件输出。

注意：hostprogs-y这类符号是所有 kbuild 文件的标准表示法，更多细节可参考 Kbuild 语法文档。在本场景中，hostprogs-y告知 kbuild 需要构建一个名为fixdep的主机程序，其源代码fixdep.c位于当前 Makefile 所在目录。执行make命令后，终端输出的第一条信息即来自该 kbuild 文件：

\$ make

HOSTCC scripts/basic/fixdep

scripts_basic目标执行完成后，archscripts目标会对arch/x86/tools目录的 Makefile 执行make命令，并指定relocs目标：

\$(Q)\$(MAKE) \$(build)=arch/x86/tools relocs

该目标会编译relocs_32.c和relocs_64.c（包含重定位信息，重定位技术详情可参考：ELF 重定位文档），终端输出如下：

HOSTCC arch/x86/tools/relocs\_32.o

HOSTCC arch/x86/tools/relocs\_64.o

HOSTCC arch/x86/tools/relocs\_common.o

HOSTLD arch/x86/tools/relocs

编译relocs.c后，会检查version.h文件：

\$(version\_h): \$(srctree)/Makefile FORCE

\$(call filechk,version.h)

\$(Q)rm -f \$(old\_version\_h)

终端输出如下：

CHK include/config/kernel.release

CHK include/generated/utsrelease.h

随后通过顶层 Makefile 中的asm-generic目标构建通用汇编头文件（生成于arch/x86/include/generated/asm目录，汇编语言详情可参考：x86 汇编指南）。asm-generic目标完成后，archprepare阶段结束，prepare0目标开始执行：

prepare0: archprepare FORCE

\$(Q)\$(MAKE) \$(build)=.

注意$(build)的定义：它来自scripts/Kbuild.include，具体如下：

build := -f \$(srctree)/scripts/Makefile.build obj

在本场景中，obj参数指定当前源代码目录（.），因此上述命令等价于：

\$(Q)\$(MAKE) -f \$(srctree)/scripts/Makefile.build obj=.

scripts/Makefile.build会根据obj参数指定的目录查找 Kbuild 文件，包含该文件并构建其中定义的目标。在当前目录（.）中，Kbuild 文件用于生成kernel/bounds.s和arch/x86/kernel/asm-offsets.s。完成这些操作后，prepare目标执行完毕。

vmlinux-dirs还依赖于scripts目标，该目标用于编译一系列工具程序：file2alias、mk_elfconfig、modpost等（这些工具详情可参考：内核模块工具文档）。scripts目录的主机程序编译完成后，vmlinux-dirs目标即可执行。首先明确vmlinux-dirs包含的内容 —— 在我的环境中，它包含以下内核目录路径：

init usr arch/x86 kernel mm fs ipc security crypto block

drivers sound firmware arch/x86/pci arch/x86/power

arch/x86/video net lib arch/x86/lib

vmlinux-dirs的定义位于顶层 Makefile：

vmlinux-dirs := \$(patsubst %/,%,\$(filter %/, \$(init-y) \$(init-m) \\

\$(core-y) \$(core-m) \$(drivers-y) \$(drivers-m) \\

\$(net-y) \$(net-m) \$(libs-y) \$(libs-m)))

init-y := init/

drivers-y := drivers/ sound/ firmware/

net-y := net/

libs-y := lib/

...

通过patsubst和filter函数移除每个目录末尾的/符号，最终生成vmlinux-dirs列表。以下代码会递归遍历vmlinux-dirs中的所有目录及其子目录（取决于配置），并在每个目录中执行make命令：

\$(vmlinux-dirs): prepare scripts

\$(Q)\$(MAKE) \$(build)=\$@

$@表示当前目标（即vmlinux-dirs中的每个目录），终端输出如下（节选）：

CC init/main.o

CHK include/generated/compile.h

CC init/version.o

CC init/do\_mounts.o

...

CC arch/x86/crypto/glue\_helper.o

AS arch/x86/crypto/aes-x86\_64-asm\_64.o

CC arch/x86/crypto/aes\_glue.o

AS arch/x86/entry/entry\_64.o

AS arch/x86/entry/thunk\_64.o

CC arch/x86/entry/syscall\_64.o

每个目录中的源代码会被编译并链接为built-in.o文件：

\$ find . -name built-in.o

./arch/x86/crypto/built-in.o

./arch/x86/crypto/sha-mb/built-in.o

./arch/x86/net/built-in.o

./init/built-in.o

./usr/built-in.o

所有built-in.o文件生成后，我们回到vmlinux目标。如前所述，vmlinux目标位于顶层 Makefile，链接vmlinux之前还会构建示例程序、文档等（本文不涉及这些内容）：

vmlinux: scripts/link-vmlinux.sh \$(vmlinux-deps) FORCE

\$(call if\_changed,link-vmlinux)

该目标的核心是调用scripts/``link-vmlinux.sh脚本，将所有built-in.o文件链接为一个静态链接的可执行文件，并生成System.map（内核符号表，符号表详情可参考：System.map 文档）。最终终端输出如下（节选）：

LINK vmlinux

LD vmlinux.o

MODPOST vmlinux.o

GEN .version

CHK include/generated/compile.h

UPD include/generated/compile.h

CC init/version.o

LD init/built-in.o

KSYM .tmp\_kallsyms1.o

KSYM .tmp\_kallsyms2.o

LD vmlinux

SORTEX vmlinux

SYSMAP System.map

此时，内核源代码根目录下会出现vmlinux和System.map文件：

\$ ls vmlinux System.map

System.map vmlinux

至此，vmlinux构建完成。下一步是生成bzImage镜像。

构建 bzImage 镜像

bzImage是压缩格式的 Linux 内核镜像（bzImage 格式详情可参考：Linux 内核镜像格式文档）。vmlinux构建完成后，可通过执行make bzImage生成该镜像；也可直接执行make命令（无任何参数），因为bzImage是默认镜像 ——arch/x86/kernel/Makefile中定义了：

all: bzImage

让我们分析该目标，理解其构建过程。bzImage目标定义在arch/x86/kernel/Makefile中，具体如下：

bzImage: vmlinux

\$(Q)\$(MAKE) \$(build)=\$(boot) \$(KBUILD\_IMAGE)

\$(Q)mkdir -p \$(objtree)/arch/\$(UTS\_MACHINE)/boot

\$(Q)ln -fsn ../../x86/boot/bzImage \$(objtree)/arch/\$(UTS\_MACHINE)/boot/\$@

首先对boot目录执行make命令（本场景中boot目录为arch/x86/boot）：

boot := arch/x86/boot

核心任务是编译arch/x86/boot和arch/x86/boot/compressed目录中的源代码，生成setup.bin和vmlinux.bin，最终合并为bzImage。

arch/x86/boot/Makefile中的第一个目标是$(obj)/setup.elf：

\$(obj)/setup.elf: \$(src)/setup.ld \$(SETUP\_OBJS) FORCE

\$(call if\_changed,ld)

arch/x86/boot目录中已存在链接脚本setup.ld，SETUP_OBJS变量包含该目录下的所有源文件。终端首先输出如下信息（节选）：

AS arch/x86/boot/bioscall.o

CC arch/x86/boot/cmdline.o

AS arch/x86/boot/copy.o

HOSTCC arch/x86/boot/mkcpustr

CPUSTR arch/x86/boot/cpustr.h

CC arch/x86/boot/cpu.o

CC arch/x86/boot/cpuflags.o

CC arch/x86/boot/cpucheck.o

CC arch/x86/boot/early\_serial\_console.o

CC arch/x86/boot/edd.o

下一个源文件是arch/x86/boot/header.S，但该目标依赖于两个头文件，因此暂不编译：

\$(obj)/header.o: \$(obj)/voffset.h \$(obj)/zoffset.h

1. 1. voffset.h：通过 sed 脚本生成，该脚本使用nm工具从vmlinux中提取两个地址（内核的起始地址和结束地址）：