VERSION = 2
# 給變量VERSION賦值
PATCHLEVEL = 6
# 給變量PATCHLEVEL賦值
SUBLEVEL = 22
# 給變量SUBLEVEL賦值
EXTRAVERSION = .6
# 給變量EXTRAVERSION賦值
NAME = Holy Dancing Manatees, Batman!
# 給變量NAME賦值
# *DOCUMENTATION*
# To see a list of typical targets execute "make help"
# More info can be located in ./README
# Comments in this file are targeted only to the developer, do not
# expect to learn how to build the kernel reading this file.
# Do not:
# o use make's built-in rules and variables
# (this increases performance and avoid hard-to-debug behavour);
# o print "Entering directory ...";
MAKEFLAGS += -rR --no-print-directory
# 操作符“+=”的作用是給變量（“+=”前面的MAKEFLAGS）追加值。
# 如果變量（“+=”前面的MAKEFLAGS）之前沒有定義過，那麼，“+=”會自動變成“=”；
# 如果前面有變量（“+=”前面的MAKEFLAGS）定義，那麼“+=”會繼承於前次操作的賦值符；
# 如果前一次的是“:=”，那麼“+=”會以“:=”作爲其賦值符
# 在執行make時的命令行選項參數被通過變量 “MAKEFLAGS”傳遞給子目錄下的make程序。
# 對於這個變量除非使用指示符“unexport”對它們進行聲明，它們在整個make的執行過程中始終被自動的傳遞給所有的子make。
# 還有個特殊變量SHELL與MAKEFLAGS一樣，默認情況（沒有用“unexport”聲明）下在整個make的執行過程中被自動的傳遞給所有的子make。
#
# -rR --no-print-directory
# -r disable the built-in impilict rules.
# -R disable the built-in variable setttings.
# --no-print-directory。
# We are using a recursive build, so we need to do a little thinking
# to get the ordering right.
#
# Most importantly: sub-Makefiles should only ever modify files in
# their own directory. If in some directory we have a dependency on
# a file in another dir (which doesn't happen often, but it's often
# unavoidable when linking the built-in.o targets which finally
# turn into vmlinux), we will call a sub make in that other dir, and
# after that we are sure that everything which is in that other dir
# is now up to date.
#
# The only cases where we need to modify files which have global
# effects are thus separated out and done before the recursive
# descending is started. They are now explicitly listed as the
# prepare rule.
# To put more focus on warnings, be less verbose as default
# Use 'make V=1' to see the full commands
ifdef V
ifeq ("$(origin V)", "command line")
KBUILD_VERBOSE = $(V)
endif
endif
ifndef KBUILD_VERBOSE
KBUILD_VERBOSE = 0
endif
# “ifdef”是條件關鍵字。語法是ifdef <variable-name>；<text-if-true>; else <text-if-false>; endif
# ifdef只檢驗一個變量是否被賦值，它並不會去推導這個變量，並不會把變量擴展到當前位置。
# “ifeq”與“ifdef”類似。
# “ifeq”語法是ifeq (<arg1>;, <arg2>;)，功能是比較參數“arg1”和“arg2”的值是否相同。
#
# 函數origin並不操作變量的值，只是告訴你你的這個變量是哪裏來的。
# 語法是： $(origin <variable>;)
# origin函數的返回值有：
# “undefined”從來沒有定義過、“default”是一個默認的定義、“environment”是一個環境變量、
# “file”這個變量被定義在Makefile中、“command line”這個變量是被命令行定義的、
# “override”是被override指示符重新定義的、“automatic”是一個命令運行中的自動化變量
#
# 應用變量的語法是：$(變量名)。如KBUILD_VERBOSE = $(V)中的$(V)。
#
# KBUILD_VERBOSE的值根據在命令行中是否定義了變量V，
# 當沒有定義時，默認爲V＝O，輸出爲short version；可以用make V=1 來輸出全部的命令。
#
# ifndef與ifdef語法類似，但功能恰好相反。ifndef是判斷變量是不是沒有被賦值。
# Call a source code checker (by default, "sparse") as part of the
# C compilation.
#
# Use 'make C=1' to enable checking of only re-compiled files.
# Use 'make C=2' to enable checking of *all* source files, regardless
# of whether they are re-compiled or not.
#
# See the file "Documentation/sparse.txt" for more details, including
# where to get the "sparse" utility.
ifdef C
ifeq ("$(origin C)", "command line")
KBUILD_CHECKSRC = $(C)
endif
endif
ifndef KBUILD_CHECKSRC
KBUILD_CHECKSRC = 0
endif
# ifdef是Makefile的條件關鍵字，其語法是：ifdef <variable-name>;
# 如果變量<variable-name>;的值非空，那到表達式爲真。否則，表達式爲假。
# ifndef也是Makefile的條將關鍵字，功能與ifdef相反，語法相似。
# Use make M=dir to specify directory of external module to build
# Old syntax make ... SUBDIRS=$PWD is still supported
# Setting the environment variable KBUILD_EXTMOD take precedence
ifdef SUBDIRS
KBUILD_EXTMOD ?= $(SUBDIRS)
endif
ifdef M
ifeq ("$(origin M)", "command line")
KBUILD_EXTMOD := $(M)
endif
endif
# ifdef是Makefile的條件關鍵字，其語法是：ifdef <variable-name>;
# 如果變量<variable-name>;的值非空，那到表達式爲真。否則，表達式爲假。
#
# ifeq是Makefile的條件關鍵字，其語法是：ifeq (<arg1>;, <arg2>;)，比較參數“arg1”和“arg2”的值是否相同。
#
# 操作符“：=”與操作符“+=”的功能相同，只是操作符“：=”後面的用來定義變量（KBUILD_EXTMOD）的變量M只能是前面定義好的，
# 如果操作符“？=”前面的變量KBUILD_EXTMOD沒有定義過，那麼就將SUBDIRS賦給KBUILD_EXTMOD；
# 如果定義過，則語句KBUILD_EXTMOD ?= $(SUBDIRS)什麼也不做。
# kbuild supports saving output files in a separate directory.
# To locate output files in a separate directory two syntaxes are supported.
# In both cases the working directory must be the root of the kernel src.
# 1) O=
# Use "make O=dir/to/store/output/files/"
#
# 2) Set KBUILD_OUTPUT
# Set the environment variable KBUILD_OUTPUT to point to the directory
# where the output files shall be placed.
# export KBUILD_OUTPUT=dir/to/store/output/files/
# make
#
# The O= assignment takes precedence over the KBUILD_OUTPUT environment
# variable.
# KBUILD_SRC is set on invocation of make in OBJ directory
# KBUILD_SRC is not intended to be used by the regular user (for now)
ifeq ($(KBUILD_SRC),)
# ifeq是Makefile的條件關鍵字，其語法是：ifeq (<arg1>;, <arg2>;)，比較參數“arg1”和“arg2”的值是否相同。
# OK, Make called in directory where kernel src resides
# Do we want to locate output files in a separate directory?
ifdef O
ifeq ("$(origin O)", "command line")
KBUILD_OUTPUT := $(O)
endif
endif
# ifdef是Makefile的條件關鍵字，其語法是：ifdef <variable-name>;
# 如果變量<variable-name>;的值非空，那到表達式爲真。否則，表達式爲假。
# ifeq是Makefile的條件關鍵字，其語法是：ifeq (<arg1>;, <arg2>;)，比較參數“arg1”和“arg2”的值是否相同。
# origin是Makefile的一個判別變量是哪裏來的函數，其語法是：$(origin <variable>;)
# That's our default target when none is given on the command line
PHONY := _all
_all:
# 爲變量PHONY追加_all
# Makefile的規則：
# 目標：依賴文件
# 命令1
# 命令2
# ...
#
# 沒有依賴文件的目標稱爲“僞目標”。僞目標並不是一個文件，只是一個標籤。
# 由於僞目標不是一個文件，所以make無法生成它的依賴關係和決定它是否要執行，
# 只有在命令行中輸入（即顯示地指明）這個“目標”才能讓其生效,此處爲"make _all"。
ifneq ($(KBUILD_OUTPUT),)
# ifneq是Makefile的條件關鍵字，其語法是：ifneq (<arg1>;, <arg2>;)，
# 功能是：比較參數“arg1”和“arg2”的值是否不相同，功能與ifeq相反。
# Invoke a second make in the output directory, passing relevant variables
# check that the output directory actually exists
saved-output := $(KBUILD_OUTPUT)
KBUILD_OUTPUT := $(shell cd $(KBUILD_OUTPUT) && /bin/pwd)
# 函數shell是make與外部環境的通訊工具，它用於命令的擴展。
# shell函數起着調用shell命令（cd $(KBUILD_OUTPUT) && /bin/pwd）和返回命令輸出結果的參數的作用。
# Make僅僅處理返回結果，再返回結果替換調用點之前，make將每一個換行符或者一對回車/換行符處理爲單個空格；
# 如果返回結果最後是換行符（和回車符），make將把它們去掉。
$(if $(KBUILD_OUTPUT),, \
$(error output directory "$(saved-output)" does not exist))
# 函數if對在函數上下文中擴展條件提供了支持（相對於GNU make makefile文件中的條件語句，例如ifeq指令。）
# if函數的語法是：$(if <condition>,<then-part>) 或是 $(if <condition>,<then-part>,<else-part>)。
# 如果條件$(KBUILD_OUTPUT)爲真（非空字符串），那麼兩個逗號之間的空字符（注意連續兩個逗號的作用）將會是整個函數的返回值，
# 如果$(KBUILD_OUTPUT)爲假（空字符串），那麼$(error output directory "$(saved-output)" does not exist）會是整個函數的返回值，
# 此時如果<else-part>沒有被定義，那麼，整個函數返回空字串。
#
# 函數error的語法是：$(error <text ...>;)
# 函數error的功能是：產生一個致命的錯誤，output directory "$(saved-output)" does not exist是錯誤信息。
# 注意，error函數不會在一被使用就會產生錯誤信息，所以如果你把其定義在某個變量中，並在後續的腳本中使用這個變量，那麼也是可以的。
#
# 命令“$(if $(KBUILD_OUTPUT),, \”中最後的“\”的作用是：緊接在“\”下面的“哪一行”的命令是“\”所在行的命令的延續。
# 如果要讓前一個命令的參數等應用與下一個命令，那麼這兩個命令應該寫在同一行，如果一行寫不下兩個命令，可以在第一行末尾添上符號"\"，然後在下一行接着寫。
# 如果是幾個命令寫在同一行，那麼後面的命令是在前面命令的基礎上執行。如 cd / ls 這兩個命令寫在同一行，那麼ls顯示的是根目錄/下的文件和文件夾。
PHONY += $(MAKECMDGOALS)
# 將變量KBUILD_OUTPUT的值追加給變量saved-output，
$(filter-out _all,$(MAKECMDGOALS)) _all:
$(if $(KBUILD_VERBOSE:1=),@)$(MAKE) -C $(KBUILD_OUTPUT) \
KBUILD_SRC=$(CURDIR) \
KBUILD_EXTMOD="$(KBUILD_EXTMOD)" -f $(CURDIR)/Makefile $@
# 反過濾函數——filter-out，語法是：$(filter-out <pattern...>;,<text>;)
# 函數filter-out的功能是：去掉$(MAKECMDGOALS）中符合規則_all的所有字符串後，剩下的作爲返回值。
# 函數filter-out調用與僞目標_all在同一行。
# 僞目標_all下面的以tab開頭的三行是命令，因爲每行最後都有"\"，所以這三行命令應該是寫在同一行的，即後面的命令要受到處於它之前的那些命令的影響。
#
# $(if $(KBUILD_VERBOSE:1=),@) 含義是如果$(KBUILD_VERBOSE:1=) 不爲空，則等於$@
# 自動化變量"$@"表示規則中的目標文件集，在模式規則中，如果有多個目標，那麼，"$@"就是匹配於目標中模式定義的集合。
# 自動化變量還有"$<"、"$%"、"$<"等。
#
# 宏變量$（MAKE）的值爲make命令和參數（參數可省）。
#
# 執行命令KBUILD_SRC=$(CURDIR)的結果是把變量CURDIR的值賦給變量KBUILD_SRC。
# CURDIR這個變量是Makefile提供的,代表了make當前的工作路徑。
# Leave processing to above invocation of make
skip-makefile := 1
endif # ifneq ($(KBUILD_OUTPUT),)
endif # ifeq ($(KBUILD_SRC),)
# 給變量skip-makefile追加值1.
# 命令endif # ifneq ($(KBUILD_OUTPUT),)的意思是這一行的endif與ifneq ($(KBUILD_OUTPUT),)相對應，
# 其實它本身已經解釋清楚了，我只是讓他變得明顯一點而已。
# 命令endif # ifeq ($(KBUILD_SRC),)的意思是這一行的endif與ifeq ($(KBUILD_SRC),)相對應。
# We process the rest of the Makefile if this is the final invocation of make
ifeq ($(skip-makefile),)
# 判斷變量skip-makefile與空字符是否相同，即判斷變量skip-makefile的值是否爲空。
# If building an external module we do not care about the all: rule
# but instead _all depend on modules
PHONY += all
ifeq ($(KBUILD_EXTMOD),)
_all: all
else
_all: modules
endif
# 爲變量PHONY追加值all。
# 判斷變量KBUILD_EXTMOD的值與空字符是否相同，即判斷變量KBUILD_EXTMOD的值是否爲空。
# 定義兩種不同情況下使用的規則_all: all和_all: modules
srctree := $(if $(KBUILD_SRC),$(KBUILD_SRC),$(CURDIR))
TOPDIR := $(srctree)
# FIXME - TOPDIR is obsolete, use srctree/objtree
# 調用if函數，根據變量KBUILD_SRC的值是否爲空，決定將變量KBUILD_SRC或者變量CURDIR的值賦給變量srctree
# 爲變量TOPDIR追加變量srctree的值
objtree := $(CURDIR)
src := $(srctree)
obj := $(objtree)
VPATH := $(srctree)$(if $(KBUILD_EXTMOD),:$(KBUILD_EXTMOD))
# “VPATH”是Makefile文件中的特殊變量。
# ，如果沒有指明這個變量，make只會在當前的目錄中去找尋依賴文件和目標文件。
# 如果定義了這個變量，那麼，make就會在噹噹前目錄找不到的情況下，到所指定的目錄中去找尋文件了。
export srctree objtree VPATH TOPDIR
# 爲變量objtree、src、obj分別追加變量CURDIR、srctree、objtree的值
# make使用“VPATH”變量來指定“依賴文件”的搜索路徑。
# 爲變量VPATH追加變量VPATH的值
# 關鍵詞export用來聲明變量，被聲明的變量要被傳遞到下級Makefile中。
# export srctree objtree VPATH TOPDIR聲明瞭四個變量，這四個變量在make嵌套時都將被傳遞到下級Makefile。
# SUBARCH tells the usermode build what the underlying arch is. That is set
# first, and if a usermode build is happening, the "ARCH=um" on the command
# line overrides the setting of ARCH below. If a native build is happening,
# then ARCH is assigned, getting whatever value it gets normally, and
# SUBARCH is subsequently ignored.
SUBARCH := $(shell uname -m | sed -e s/i.86/i386/ -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/ )
# 爲變量SUBARCH追加調用shell執行sed後的返回值。
# sed 是一種在線編輯器，它一次處理一行內容。
# Sed主要用來自動編輯一個或多個文件；簡化對文件的反覆操作；編寫轉換程序等。
# Cross compiling and selecting different set of gcc/bin-utils
# ---------------------------------------------------------------------------
#
# When performing cross compilation for other architectures ARCH shall be set
# to the target architecture. (See arch/* for the possibilities).
# ARCH can be set during invocation of make:
# make ARCH=ia64
# Another way is to have ARCH set in the environment.
# The default ARCH is the host where make is executed.
# Cross compiling and selecting different set of gcc/bin-utils
# ---------------------------------------------------------------------------
#
# When performing cross compilation for other architectures ARCH shall be set
# to the target architecture. (See arch/* for the possibilities).
# ARCH can be set during invocation of make:
# make ARCH=ia64
# Another way is to have ARCH set in the environment.
# The default ARCH is the host where make is executed.
# CROSS_COMPILE specify the prefix used for all executables used
# during compilation. Only gcc and related bin-utils executables
# are prefixed with $(CROSS_COMPILE).
# CROSS_COMPILE can be set on the command line
# make CROSS_COMPILE=ia64-linux-
# Alternatively CROSS_COMPILE can be set in the environment.
# Default value for CROSS_COMPILE is not to prefix executables
# Note: Some architectures assign CROSS_COMPILE in their arch/*/Makefile
# 上面已經說了，下面的這些是用於交叉編譯（嵌入式linux的編譯環境就是交叉編譯）。
# 如果你不清楚嵌入式linux是什麼，但是你又想知道它，記住：www.baidu.com
ARCH ?= $(SUBARCH)
CROSS_COMPILE ?=
# 變量ARCH用來指明目標cpu的構架
# 設置變量ARCH的方法有兩種，
# 一是：在命令行中 如：make ARCH=ia64；
# 二是：設置環境變量，在環境變量中默認的ARCH的值是執行make的cpu構架
# 不論怎麼弄，目的就是使編譯出來的目標文件（可執行文件）面向的是你的目標平臺（在嵌入式開發中）。
#
# 操作符“?= ”的作用是：如果ARCH未被定義過，那麼將變量SUBARCH的值賦給變量ARCH，
# 如果變量ARCH已經被定義過，那麼這條語句什麼也不做。
#
# ARCH指定在嵌入式開發中你的目標板上的cpu類型（構架），如：arm，ppc，powerpc等
# 變量CROSS_COMPILE指定交叉編譯用的交叉編譯器，這裏的CROSS_COMPILE就是讓你指定交叉編譯器的路徑。
# 如果你設置好了PATH那麼直接把這句加上就可以,如果沒有那麼請指定路徑，
# Architecture as present in compile.h
UTS_MACHINE := $(ARCH)
# 將變量ARCH直接展開給變量UTS_MACHINE。
KCONFIG_CONFIG ?= .config
# 在變量KCONFIG_CONFIG沒賦值的情況下，將.config賦給變量KCONFIG_CONFIG；如果已經賦值，那麼什麼也不做。
# SHELL used by kbuild
CONFIG_SHELL := $(shell if [ -x "$$BASH" ]; then echo $$BASH; \
else if [ -x /bin/bash ]; then echo /bin/bash; \
else echo sh; fi ; fi)
# 將生成shell程序來執行if函數後返回的結果展開給變量CONFIG_SHELL；
# if函數中，在else中又嵌套了if函數。
HOSTCC = gcc
HOSTCXX = g++
HOSTCFLAGS = -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer
HOSTCXXFLAGS = -O2
# 分別爲變量HOSTCC 、HOSTCXX 、HOSTCFLAGS 、HOSTCXXFLAGS賦值。
# Decide whether to build built-in, modular, or both.
# Normally, just do built-in.
KBUILD_MODULES :=
KBUILD_BUILTIN := 1
# 分別爲變量KBUILD_MODULES、KBUILD_BUILTIN 賦值。
# If we have only "make modules", don't compile built-in objects.
# When we're building modules with modversions, we need to consider
# the built-in objects during the descend as well, in order to
# make sure the checksums are up to date before we record them.
ifeq ($(MAKECMDGOALS),modules)
KBUILD_BUILTIN := $(if $(CONFIG_MODVERSIONS),1)
endif
# ifeq判斷變量MAKECMDGOALS的值與modules是否相同；
# 第二行將調用if後返回的值展開給變量KBUILD_BUILTIN；
# if函數判斷變量CONFIG_MODVERSIONS的值是否爲非空字符串，如果是非空字符串，則執行逗號後面的1
# If we have "make <whatever> modules", compile modules
# in addition to whatever we do anyway.
# Just "make" or "make all" shall build modules as well
ifneq ($(filter all _all modules,$(MAKECMDGOALS)),)
KBUILD_MODULES := 1
endif
# ifneq判斷調用函數filter的返回值與空字符串是否相同。
# 如果相同，那麼執行第二行，即把1賦給變量 KBUILD_MODULES
ifeq ($(MAKECMDGOALS),)
KBUILD_MODULES := 1
endif
# ifeq判斷變量MAKECMDGOALS的值是否與空字符相同。如果相同，則執行第二行；
# 第二行是把1賦給變量KBUILD_MODULES。
export KBUILD_MODULES KBUILD_BUILTIN
export KBUILD_CHECKSRC KBUILD_SRC KBUILD_EXTMOD
# 用關鍵詞export聲明變量KBUILD_MODULES KBUILD_BUILTIN、KBUILD_CHECKSRC KBUILD_SRC KBUILD_EXTMOD。
# 如果用關鍵詞export聲明瞭變量，那麼被聲明的變量將會被傳遞到下級Makefile中。
# Beautify output
# ---------------------------------------------------------------------------
#
# Normally, we echo the whole command before executing it. By making
# that echo $($(quiet)$(cmd)), we now have the possibility to set
# $(quiet) to choose other forms of output instead, e.g.
#
# quiet_cmd_cc_o_c = Compiling $(RELDIR)/$@
# cmd_cc_o_c = $(CC) $(c_flags) -c -o $@ $<
#
# If $(quiet) is empty, the whole command will be printed.
# If it is set to "quiet_", only the short version will be printed.
# If it is set to "silent_", nothing will be printed at all, since
# the variable $(silent_cmd_cc_o_c) doesn't exist.
#
# A simple variant is to prefix commands with $(Q) - that's useful
# for commands that shall be hidden in non-verbose mode.
#
# $(Q)ln $@ :<
#
# If KBUILD_VERBOSE equals 0 then the above command will be hidden.
# If KBUILD_VERBOSE equals 1 then the above command is displayed.
ifeq ($(KBUILD_VERBOSE),1)
quiet =
Q =
else
quiet=quiet_
Q = @
endif
# 函數ifeq判斷變量KBUILD_VERBOSE的值與1是否相同。如果相同則執行第二三行，否則執行五六行。
# 二三五六行都是爲變量賦值。
# If the user is running make -s (silent mode), suppress echoing of
# commands
ifneq ($(findstring s,$(MAKEFLAGS)),)
quiet=silent_
endif
# 函數ifneq判斷函數findstring返回值與空字符是否相同，如果相同則執行第二行（將silent_賦給變量quiet）。
# 函數findstring的語法是：$(findstring <find>;,<in>;)
# 函數findstring的功能是：如果在$(MAKEFLAGS)中能找到字符s，那麼返回字符s；否則返回空字符。
export quiet Q KBUILD_VERBOSE
# 用關鍵詞export聲明變量quiet Q KBUILD_VERBOSE，使得它們能被傳到下級Makefile。
# Look for make include files relative to root of kernel src
MAKEFLAGS += --include-dir=$(srctree)
# 給變量MAKEFLAGS追加--include-dir=$(srctree)。
# --include-dir是make的參數，用來指定一個被包含makefile的搜索目標。
# 也可以使用多個“-I”參數來指定多個目錄。
# We need some generic definitions.
include $(srctree)/scripts/Kbuild.include
# 在Makefile使用include關鍵字可以把別的Makefile包含進來。
# 這很像C語言的#include，被包含的文件會原模原樣的放在當前文件的包含位置。
# include的語法是： include <filename>;
# Make variables (CC, etc...)
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
GENKSYMS = scripts/genksyms/genksyms
DEPMOD = /sbin/depmod
KALLSYMS = scripts/kallsyms
PERL = perl
CHECK = sparse
CHECKFLAGS := -D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ -Wbitwise $(CF)
MODFLAGS = -DMODULE
CFLAGS_MODULE = $(MODFLAGS)
AFLAGS_MODULE = $(MODFLAGS)
LDFLAGS_MODULE = -r
CFLAGS_KERNEL =
AFLAGS_KERNEL =
# 給一系列變量賦值。
# Use LINUXINCLUDE when you must reference the include/ directory.
# Needed to be compatible with the O= option
LINUXINCLUDE := -Iinclude \
$(if $(KBUILD_SRC),-Iinclude2 -I$(srctree)/include) \
-include include/linux/autoconf.h
# 爲變量LINUXINCLUDE賦值。
CPPFLAGS := -D__KERNEL__ $(LINUXINCLUDE)
CFLAGS := -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs \
-fno-strict-aliasing -fno-common
AFLAGS := -D__ASSEMBLY__
# 給FLAGS系列變量賦值。
# Read KERNELRELEASE from include/config/kernel.release (if it exists)
KERNELRELEASE = $(shell cat include/config/kernel.release 2> /dev/null)
KERNELRELEASE = $(VERSION).$(PATCHLEVEL).$(SUBLEVEL)$(EXTRAVERSION)
# 給變量KERNELRELEASE、KERNELRELEASE賦值。
# >是重定向符號。
# 第一行中cat和>連用的作用是：將文件include/config/kernel.release的內容寫入到文件/dev/null中。
export VERSION PATCHLEVEL SUBLEVEL KERNELRELEASE KERNELVERSION
export ARCH CONFIG_SHELL HOSTCC HOSTCFLAGS CROSS_COMPILE AS LD CC
export CPP AR NM STRIP OBJCOPY OBJDUMP MAKE AWK GENKSYMS PERL UTS_MACHINE
export HOSTCXX HOSTCXXFLAGS LDFLAGS_MODULE CHECK CHECKFLAGS
export CPPFLAGS NOSTDINC_FLAGS LINUXINCLUDE OBJCOPYFLAGS LDFLAGS
export CFLAGS CFLAGS_KERNEL CFLAGS_MODULE
export AFLAGS AFLAGS_KERNEL AFLAGS_MODULE
# 用關鍵詞export聲明變量，使得這些變量能傳到下級Makefile中
# When compiling out-of-tree modules, put MODVERDIR in the module
# tree rather than in the kernel tree. The kernel tree might
# even be read-only.
export MODVERDIR := $(if $(KBUILD_EXTMOD),$(firstword $(KBUILD_EXTMOD))/).tmp_versions
# 用關鍵詞export聲明變量MODVERDIR，使得變量MODVERDIR能傳到下級Makefile中
# 將if函數的返回值展開後與.tmp_versions共同賦給變量MODVERDIR。
# if函數判斷變量KBUILD_EXTMOD的值是否爲空字符串，如果不爲空字符串，執行函數firstword。
# 函數firstword的語法是：$(firstword <text>;)。
# 函數firstword在此處的功能是：取出變量KBUILD_EXTMOD的第一個字符。
# Files to ignore in find ... statements
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
# 分別爲變量RCS_FIND_IGNORE、RCS_FIND_IGNORE賦值。
# 第二行中用關鍵詞export聲明變量RCS_TAR_IGNORE，使它能夠傳遞到下級Makefile中。
# 反斜槓\在第一行中只有轉義的作用，不表示續行。
# 即\後面的“（”和“）”都不表示前括號和後括號，而是兩個字符。
# -name是命令find的一個參數，參數-name用來指明要搜索的文件的部分或者全名。
# -o 是 OR 運算符，語法是：表達式-o 表達式、如果第一個表達式是真，就不會對第二個表達式求值。
# ===========================================================================
# Rules shared between *config targets and build targets
# Basic helpers built in scripts/
PHONY += scripts_basic
scripts_basic:
$(Q)$(MAKE) $(build)=scripts/basic
# 爲變量PHONY追加scripts_basic。
# 定義了一個僞目標scripts_basic，第三行是針對僞目標scripts_basic要執行的命令。
# 第三行是將變量展開，展開後是一個命令。
# To avoid any implicit rule to kick in, define an empty command.
scripts/basic/%: scripts_basic ;
# 定義了一個規則，依賴關係爲scripts/basic/%: scripts_basic
# 冒號：的作用是定義一個空命令（正如上面解釋所說）。
PHONY += outputmakefile
# 爲變量PHONY追加outputmakefile。
# outputmakefile generates a Makefile in the output directory, if using a
# separate output directory. This allows convenient use of make in the
# output directory.
outputmakefile:
ifneq ($(KBUILD_SRC),)
$(Q)$(CONFIG_SHELL) $(srctree)/scripts/mkmakefile \
$(srctree) $(objtree) $(VERSION) $(PATCHLEVEL)
endif
# 定義一個僞目標outputmakefile。
# 將三四行中所有的變量展開並且合併成一行命令。
# To make sure we do not include .config for any of the *config targets
# catch them early, and hand them over to scripts/kconfig/Makefile
# It is allowed to specify more targets when calling make, including
# mixing *config targets and build targets.
# For example 'make oldconfig all'.
# Detect when mixed targets is specified, and make a second invocation
# of make so .config is not included in this case either (for *config).
no-dot-config-targets := clean mrproper distclean \
cscope TAGS tags help %docs check% \
include/linux/version.h headers_% \
kernelrelease kernelversion
# 定義了一個依賴關係，但是沒有命令。
config-targets := 0
mixed-targets := 0
dot-config := 1
# 給變量config-targets、mixed-targets、dot-config 賦值。
ifneq ($(filter $(no-dot-config-targets), $(MAKECMDGOALS)),)
ifeq ($(filter-out $(no-dot-config-targets), $(MAKECMDGOALS)),)
dot-config := 0
endif
endif
# 條件關鍵詞ifneq判斷filter函數的返回值與變量MAKECMDGOALS是否相同，如果相同，則執行第二行。
# 第二行，條件關鍵詞ifeq判斷函數filter-out返回值與變量MAKECMDGOALS是否相同，如果相同則執行第三行。
# 函數filter的語法是：$(filter <pattern...>;,<text>;)。
# 功能是：返回 $(MAKECMDGOALS)中符合模式$(no-dot-config-targets)的字符串
# 函數filter-out與函數filter在語法是相似，在功能上恰好相反。
# 函數filter-out返回字符串$(MAKECMDGOALS)中不符合模式$(no-dot-config-targets)的字符串。
# 第三行是給變量dot-config賦值0.
ifeq ($(KBUILD_EXTMOD),)
ifneq ($(filter config %config,$(MAKECMDGOALS)),)
config-targets := 1
ifneq ($(filter-out config %config,$(MAKECMDGOALS)),)
mixed-targets := 1
endif
endif
endif
# 條件關鍵詞ifeq判斷KBUILD_EXTMOD的值與空格是否相同，如果是則執行第二行。
# 條件關鍵詞ifneq判斷函數filter的返回值與空格是否不相同，如果不相同，則執行第三行。
# 函數filter返回字符串$(MAKECMDGOALS))中符合模式config %config的字符串。
# 第三行爲變量config-targets賦值1
# 條件關鍵詞ifneq判斷函數filter-out返回值與空格是否不相同，如果不過不相同則執行第五行。
# 函數filter-out返回字符串$(MAKECMDGOALS)中不符合模式config %config的字符串。
# 第五行爲變量mixed-targets賦值1.
ifeq ($(mixed-targets),1)
# 條件關鍵詞ifeq判斷變量mixed-targets的值與1是否相同，即是否爲1
# ===========================================================================
# We're called with mixed targets (*config and build targets).
# Handle them one by one.
%:: FORCE
$(Q)$(MAKE) -C $(srctree) KBUILD_SRC= $@
# 定義了目標“%:”，依賴文件FORCE
# 第二行，將所有變量展開後組成一行命令。
# 條件關鍵詞ifeq判斷變量mixed-targets的值與1是否相同，即是否爲1
# ===========================================================================
# We're called with mixed targets (*config and build targets).
# Handle them one by one.
else
ifeq ($(config-targets),1)
# 如果變量mixed-targets的值與1不相同，則執行else後面的（即執行第二行）。
# 條件關鍵詞ifeq判斷變量config-targets的值與1是否相同。
# ===========================================================================
# *config targets only - make sure prerequisites are updated, and descend
# in scripts/kconfig to make the *config target
# Read arch specific Makefile to set KBUILD_DEFCONFIG as needed.
# KBUILD_DEFCONFIG may point out an alternative default configuration
# used for 'make defconfig'
include $(srctree)/arch/$(ARCH)/Makefile
export KBUILD_DEFCONFIG
# 如果變量config-targets的值與1相同，則執行從第一行開始直到遇到下面的else結束。
# 關鍵詞include將文件$(srctree)/arch/$(ARCH)/Makefile包含進來，
# 文件$(srctree)/arch/$(ARCH)/Makefile被原模原樣的放在當前文件的包含位置。
# 關鍵詞export聲明變量KBUILD_DEFCONFIG使得變量KBUILD_DEFCONFIG能傳到下級Makefile中。
config %config: scripts_basic outputmakefile FORCE
$(Q)mkdir -p include/linux include/config
$(Q)$(MAKE) $(build)=scripts/kconfig $@
# 定義了一個規則，目標位config %config其中有個通配符%。
# 通配符%只能代表一個字符，config %config可以表示xconfig和gconfig、menuconfig和oldconfig等。
# 二三行將變量展開後就規則得到要執行的命令。
else
# 如果變量config-targets的值與1不相同，則執行下面的
# ===========================================================================
# Build targets only - this includes vmlinux, arch specific targets, clean
# targets and others. In general all targets except *config targets.
ifeq ($(KBUILD_EXTMOD),)
# 條件關鍵詞ifeq判斷變量KBUILD_EXTMOD的值與空是否相同。
# Additional helpers built in scripts/
# Carefully list dependencies so we do not try to build scripts twice
# in parallel
PHONY += scripts
scripts: scripts_basic include/config/auto.conf
$(Q)$(MAKE) $(build)=$(@)
# 第一行給變量PHONY追加scripts。
# 定義了一個規則。目標是scripts，依賴文件是scripts_basic include/config/auto.conf
# 將第三行的所有命令展開就得到規則的命令。
# Objects we will link into vmlinux / subdirs we need to visit
init-y := init/
drivers-y := drivers/ sound/
net-y := net/
libs-y := lib/
core-y := usr/
endif # KBUILD_EXTMOD
# 爲變量賦值。
# 上面的endif與ifeq ($(KBUILD_EXTMOD),)相對應。
ifeq ($(dot-config),1)
# Read in config
-include include/config/auto.conf
# 條件關鍵詞ifeq判斷變量dot-config的值與1是否相同，如果相同這執行上面這一條。
# 關鍵詞include將文件include/config/auto.conf包含進來，該文件會原模原樣的放在當前文件的包含位置。
# 關鍵詞include前面的減號的作用是讓make不理那些無法讀取的文件，而繼續執行。
ifeq ($(KBUILD_EXTMOD),)
# Read in dependencies to all Kconfig* files, make sure to run
# oldconfig if changes are detected.
-include include/config/auto.conf.cmd
# 條件關鍵詞ifeq判斷變量KBUILD_EXTMOD的值與0是否相同，如果相同這執行上面這一條。
# 關鍵詞include將文件include/config/auto.conf.cmd包含進來，該文件會原模原樣的放在當前文件的包含位置。
# 關鍵詞include前面的減號的作用是讓make不理那些無法讀取的文件，而繼續執行。
# To avoid any implicit rule to kick in, define an empty command
$(KCONFIG_CONFIG) include/config/auto.conf.cmd: ;
# 定義了一個規則，目標是$(KCONFIG_CONFIG) include/config/auto.conf.cmd，沒有依賴文件，命令。
# If .config is newer than include/config/auto.conf, someone tinkered
# with it and forgot to run make oldconfig.
# if auto.conf.cmd is missing then we are probably in a cleaned tree so
# we execute the config step to be sure to catch updated Kconfig files
include/config/auto.conf: $(KCONFIG_CONFIG) include/config/auto.conf.cmd
$(Q)$(MAKE) -f $(srctree)/Makefile silentoldconfig
else
# 第一二行定義了一個規則。
# 目標是include/config/auto.conf，依賴文件是$(KCONFIG_CONFIG) include/config/auto.conf.cmd
# 將第二行的變量展開就得到命令。
# 上面的else與ifeq ($(KBUILD_EXTMOD),)對應
# external modules needs include/linux/autoconf.h and include/config/auto.conf
# but do not care if they are up-to-date. Use auto.conf to trigger the test
PHONY += include/config/auto.conf
# 爲變量PHONY追加值include/config/auto.conf
include/config/auto.conf:
# 定義了一個僞目標
$(Q)test -e include/linux/autoconf.h -a -e $@ || ( \
echo; \
echo " ERROR: Kernel configuration is invalid."; \
echo " include/linux/autoconf.h or $@ are missing."; \
echo " Run 'make oldconfig && make prepare' on kernel src to fix it."; \
echo; \
/bin/false)
# 自動變量$@表示當前規則的目標變量名。
# echo是shell中的顯示命令，顯示echo後面的字符串。
endif # KBUILD_EXTMOD
# 上面的endif與ifeq ($(KBUILD_EXTMOD),)對應。
else
# Dummy target needed, because used as prerequisite
include/config/auto.conf: ;
endif # $(dot-config)
# 定義了一個僞目標include/config/auto.conf，該規則沒有依賴文件和命令。
# 上面的endif與ifeq ($(dot-config),1)對應。
# The all: target is the default when no target is given on the
# command line.
# This allow a user to issue only 'make' to build a kernel including modules
# Defaults vmlinux but it is usually overridden in the arch makefile
all: vmlinux
# 定義了一個依賴關係，目標是all，依賴文件是vmlinux。
ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE
CFLAGS += -Os
else
CFLAGS += -O2
endif
# 條件關鍵字ifdef只檢驗變量CONFIG_CC_OPTIMIZE_FOR_SIZE是否被賦值（非空）。
# 分別在兩種情況下爲變量CFLAGS追加不同的值。
include $(srctree)/arch/$(ARCH)/Makefile
# 用關鍵字聲明文件$(srctree)/arch/$(ARCH)/Makefile，使得該文件能傳遞到下級Makefile
ifdef CONFIG_FRAME_POINTER
CFLAGS += -fno-omit-frame-pointer $(call cc-option,-fno-optimize-sibling-calls,)
else
CFLAGS += -fomit-frame-pointer
endif
# 條件關鍵字ifdef只檢驗變量CONFIG_FRAME_POINTER是否被賦值（非空）。
# 分別在兩種情況下爲變量CFLAGS追加不同的值。
ifdef CONFIG_DEBUG_INFO
CFLAGS += -g
endif
# 條件關鍵字ifdef只檢驗變量CONFIG_DEBUG_INFO是否被賦值（非空）。
# 爲變量CFLAGS追加-g
# Force gcc to behave correct even for buggy distributions
CFLAGS += $(call cc-option, -fno-stack-protector)
# 爲變量CFLAGS追加$(call cc-option, -fno-stack-protector)。
# arch Makefile may override CC so keep this after arch Makefile is included
NOSTDINC_FLAGS += -nostdinc -isystem $(shell $(CC) -print-file-name=include)
CHECKFLAGS += $(NOSTDINC_FLAGS)
# 分別爲變量追加值
# 函數shell新生成一個Shell程序來執行由變量CC展開後形成的命令。
# warn about C99 declaration after statement
CFLAGS += $(call cc-option,-Wdeclaration-after-statement,)
# 爲變量CFLAGS追加call函數返回的函數call的返回值。
# 函數call的語法：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)。
# 函數call的功能是：參數cc-option中的變量被字符串-Wdeclaration-after-statement和逗號後面的空格依次取代。
# 函數call的返回值是：被取代後的參數。
# disable pointer signed / unsigned warnings in gcc 4.0
CFLAGS += $(call cc-option,-Wno-pointer-sign,)
# 爲變量CFLAGS追加call函數返回的函數call的返回值。
# 函數call的語法：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)。
# # 函數call的功能是：參數cc-option中的變量被字符串-Wno-pointer-sign和逗號後面的空格依次取代。
# Default kernel image to build when no specific target is given.
# KBUILD_IMAGE may be overruled on the command line or
# set in the environment
# Also any assignments in arch/$(ARCH)/Makefile take precedence over
# this default value
export KBUILD_IMAGE ?= vmlinux
# 用關鍵字聲明瞭變量KBUILD_IMAGE，使得該變量能傳遞到下級Makefile中。
# 符號“?=”在變量KBUILD_IMAGE沒有賦值的情況下給變量KBUILD_IMAGE賦值，如果已經賦值了則什麼也不做。
#
# INSTALL_PATH specifies where to place the updated kernel and system map
# images. Default is /boot, but you can set it to other values
export INSTALL_PATH ?= /boot
# 用關鍵字聲明瞭變量INSTALL_PATH，使得該變量能傳遞到下級Makefile中。
# 符號“?=”在變量INSTALL_PATH沒有賦值的情況下給變量INSTALL_PATH賦值，如果已經賦值了則什麼也不做。
#
# INSTALL_MOD_PATH specifies a prefix to MODLIB for module directory
# relocations required by build roots. This is not defined in the
# makefile but the argument can be passed to make if needed.
#
MODLIB = $(INSTALL_MOD_PATH)/lib/modules/$(KERNELRELEASE)
export MODLIB
# 給變量MODLIB賦值
# 用關鍵字聲明變量MODLIB使得變量能夠傳到下級Makefile
#
# INSTALL_MOD_STRIP, if defined, will cause modules to be
# stripped after they are installed. If INSTALL_MOD_STRIP is '1', then
# the default option --strip-debug will be used. Otherwise,
# INSTALL_MOD_STRIP will used as the options to the strip command.
ifdef INSTALL_MOD_STRIP
ifeq ($(INSTALL_MOD_STRIP),1)
mod_strip_cmd = $(STRIP) --strip-debug
else # 這個else與ifeq ($(INSTALL_MOD_STRIP),1)對應。
mod_strip_cmd = $(STRIP) $(INSTALL_MOD_STRIP)
endif # INSTALL_MOD_STRIP=1
else # 這個else與ifdef INSTALL_MOD_STRIP對應。
mod_strip_cmd = true
endif # INSTALL_MOD_STRIP
export mod_strip_cmd
# 條件關鍵字ifdef判斷變量INSTALL_MOD_STRIP是否被賦值，
# 條件關鍵字ifeq判斷變量INSTALL_MOD_STRIP與1是否相同。
# 如果相同或被賦值則執行緊接着的命令，否則執行同一級的else後的命令。
# 上面命令就是在不同情況下給變量mod_strip_cmd賦值。
core-y += kernel/ mm/ fs/ ipc/ security/ crypto/ block/
# 條件關鍵字ifeq判斷變量KBUILD_EXTMOD的值與空格是否相同，如果是則爲變量core-y追加值。
vmlinux-dirs := $(patsubst %/,%,$(filter %/, $(init-y) $(init-m) \
$(core-y) $(core-m) $(drivers-y) $(drivers-m) \
$(net-y) $(net-m) $(libs-y) $(libs-m)))
# 將函數patsubst的返回值賦給變量vmlinux-dirs。
# 函數patsubst的語法是：$(patsubst <pattern>;,<replacement>;,<text>;)。
# 函數patsubst的作用是：用“%”替換函數filter返回的字符串中的“%”。
# 函數filter的作用是：
# 函數filter的作用是：返回字符串中符合模式“%/”的字符串。
vmlinux-alldirs := $(sort $(vmlinux-dirs) $(patsubst %/,%,$(filter %/, \
$(init-n) $(init-) \
$(core-n) $(core-) $(drivers-n) $(drivers-) \
$(net-n) $(net-) $(libs-n) $(libs-))))
# 將函數sort返回的值賦給變量vmlinux-alldirs 。
# 函數sort的語法：$(sort <list>;)。
# 函數sort的返回值是：去掉相同的單詞，給字符串<list>;中的單詞排序（升序），返回排序後的字符串。
# 第一行中的patsubst是模式字符串替換函數，語法是：$(patsubst <pattern>;,<replacement>;,<text>;)。
# 在<text>中查找匹配模式”%/“的單詞，並用”%“替換它們，最後返回替換後的字符串。
init-y := $(patsubst %/, %/built-in.o, $(init-y))
core-y := $(patsubst %/, %/built-in.o, $(core-y))
drivers-y := $(patsubst %/, %/built-in.o, $(drivers-y))
net-y := $(patsubst %/, %/built-in.o, $(net-y))
libs-y1 := $(patsubst %/, %/lib.a, $(libs-y))
libs-y2 := $(patsubst %/, %/built-in.o, $(libs-y))
libs-y := $(libs-y1) $(libs-y2)
# 上面的幾個命令中，前幾個是把函數patsubst返回值賦給左邊的變量，最後一個直接把變量展開賦給左邊的變量。
# 函數patsubst的語法是：$(patsubst <pattern>;,<replacement>;,<text>;)。
# 功能是：在字符串<text>;中查找與模式<pattern>;匹配的單詞、替換它們，最後返回替換後的字符串。
# Build vmlinux
# ---------------------------------------------------------------------------
# vmlinux is built from the objects selected by $(vmlinux-init) and
# $(vmlinux-main). Most are built-in.o files from top-level directories
# in the kernel tree, others are specified in arch/$(ARCH)/Makefile.
# Ordering when linking is important, and $(vmlinux-init) must be first.
#
# vmlinux
# ^
# |
# +-< $(vmlinux-init)
# | +--< init/version.o + more
# |
# +--< $(vmlinux-main)
# | +--< driver/built-in.o mm/built-in.o + more
# |
# +-< kallsyms.o (see description in CONFIG_KALLSYMS section)
#
# vmlinux version (uname -v) cannot be updated during normal
# descending-into-subdirs phase since we do not yet know if we need to
# update vmlinux.
# Therefore this step is delayed until just before final link of vmlinux -
# except in the kallsyms case where it is done just before adding the
# symbols to the kernel.
#
# System.map is generated to document addresses of all kernel symbols
vmlinux-init := $(head-y) $(init-y)
vmlinux-main := $(core-y) $(libs-y) $(drivers-y) $(net-y)
vmlinux-all := $(vmlinux-init) $(vmlinux-main)
vmlinux-lds := arch/$(ARCH)/kernel/vmlinux.lds
export KBUILD_VMLINUX_OBJS := $(vmlinux-all)
# 上面的命令都是給變量賦值。
# 最後一行命令中有關鍵詞export，被export聲明的變量能傳到下級Makefile。
# Rule to link vmlinux - also used during CONFIG_KALLSYMS
# May be overridden by arch/$(ARCH)/Makefile
quiet_cmd_vmlinux__ ?= LD $@
cmd_vmlinux__ ?= $(LD) $(LDFLAGS) $(LDFLAGS_vmlinux) -o $@ \
-T $(vmlinux-lds) $(vmlinux-init) \
--start-group $(vmlinux-main) --end-group \
$(filter-out $(vmlinux-lds) $(vmlinux-init) $(vmlinux-main) FORCE ,$^)
# 賦值操作符"?="的作用是在他左邊的變量還未賦值的情況下，把他右邊的賦給左邊的變量。
# 反過濾函數filter-out的語法是：$(filter-out <pattern...>;,<text>;)
# 功能是:返回字符串$^中不符合模式(vmlinux-lds) $(vmlinux-init) $(vmlinux-main) FORCE的字符串。
# Generate new vmlinux version
quiet_cmd_vmlinux_version = GEN .version
cmd_vmlinux_version = set -e; \
if [ ! -r .version ]; then \
rm -f .version; \
echo 1 >.version; \
else \
mv .version .old_version; \
expr 0$$(cat .old_version) + 1 >.version; \
fi; \
$(MAKE) $(build)=init
# 上面是給兩個變量quiet_cmd_vmlinux_version、cmd_vmlinux_version 賦值。
# 其中set、if...then...else... 、rm、echo、expr等是linux shell中的命令。
# Generate System.map
quiet_cmd_sysmap = SYSMAP
cmd_sysmap = $(CONFIG_SHELL) $(srctree)/scripts/mksysmap
# 上面的是給變量quiet_cmd_sysmap和cmd_sysmap賦值。
# Link of vmlinux
# If CONFIG_KALLSYMS is set .version is already updated
# Generate System.map and verify that the content is consistent
# Use + in front of the vmlinux_version rule to silent warning with make -j2
# First command is ':' to allow us to use + in front of the rule
define rule_vmlinux__
:
$(if $(CONFIG_KALLSYMS),,+$(call cmd,vmlinux_version))
$(call cmd,vmlinux__)
$(Q)echo 'cmd_$@ := $(cmd_vmlinux__)' > $(@D)/.$(@F).cmd
$(Q)$(if $($(quiet)cmd_sysmap), \
echo ' $($(quiet)cmd_sysmap) System.map' &&) \
$(cmd_sysmap) $@ System.map; \
if [ $$? -ne 0 ]; then \
rm -f $@; \
/bin/false; \
fi;
$(verify_kallsyms)
endef
# 關鍵詞define...endef的作用是：爲相同的命令序列定義一個變量，又稱定義命令包。
# 上面定義了一個命令包，這個命令包的名字是（define後的）rule_vmlinux__；
# 命令序列是：從define下面的那一行開始，直到endef的（包括）上面一行。
# 函數if的語法是：$(if <condition>;,<then-part>;,<else-part>;) 。
# 在if函數中，如果CONFIG_KALLSYMS的值爲非空字符串，
# 那麼執行<then-part>;部分（這裏爲空即第一二個逗號之間的部分）；
# 如果CONFIG_KALLSYMS的值爲空字符串（即爲假），則執行+$(call cmd,vmlinux_version)。
# 函數call的語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
# 功能是：用參數<parm1>;,<parm2>;,<parm3>;...依次取代參數<expression>中的變量，
# 並返回取代後的<expression>。
# echo是linux shell中的一個顯示文字的命令，語法是：：echo [-ne][字符串]或 echo [--help][--version]
# rm是linux shell中的一個刪除文件、文件夾的命令。
ifdef CONFIG_KALLSYMS
# 條件關鍵詞ifdef判斷變量CONFIG_KALLSYMS是否非空。
# Generate section listing all symbols and add it into vmlinux $(kallsyms.o)
# It's a three stage process:
# o .tmp_vmlinux1 has all symbols and sections, but __kallsyms is
# empty
# Running kallsyms on that gives us .tmp_kallsyms1.o with
# the right size - vmlinux version (uname -v) is updated during this step
# o .tmp_vmlinux2 now has a __kallsyms section of the right size,
# but due to the added section, some addresses have shifted.
# From here, we generate a correct .tmp_kallsyms2.o
# o The correct .tmp_kallsyms2.o is linked into the final vmlinux.
# o Verify that the System.map from vmlinux matches the map from
# .tmp_vmlinux2, just in case we did not generate kallsyms correctly.
# o If CONFIG_KALLSYMS_EXTRA_PASS is set, do an extra pass using
# .tmp_vmlinux3 and .tmp_kallsyms3.o. This is only meant as a
# temporary bypass to allow the kernel to be built while the
# maintainers work out what went wrong with kallsyms.
ifdef CONFIG_KALLSYMS_EXTRA_PASS
last_kallsyms := 3
else # 這個else與ifdef CONFIG_KALLSYMS_EXTRA_PASS對應
last_kallsyms := 2
endif # 這個endif與ifdef CONFIG_KALLSYMS_EXTRA_PASS對應
# 嵌套了一個ifdef。
# 如果變量CONFIG_KALLSYMS_EXTRA_PASS是非空，則執行else前面的部分，否則執行else到endif之間的部分。
kallsyms.o := .tmp_kallsyms$(last_kallsyms).o
# 爲變量kallsyms.o 賦值。
define verify_kallsyms
$(Q)$(if $($(quiet)cmd_sysmap), \
echo ' $($(quiet)cmd_sysmap) .tmp_System.map' &&) \
$(cmd_sysmap) .tmp_vmlinux$(last_kallsyms) .tmp_System.map
$(Q)cmp -s System.map .tmp_System.map || \
(echo Inconsistent kallsyms data; \
echo Try setting CONFIG_KALLSYMS_EXTRA_PASS; \
rm .tmp_kallsyms* ; /bin/false )
endef
# 關鍵詞define定義了一個叫verify_kallsyms的命令包。
# 定義這種命令序列的語法以“define”開始，以“endef”結束。
# 函數if的語法是：$(if <condition>;,<then-part>;,<else-part>;)。
# 如果($(quiet)cmd_sysmap), 返回爲非空字符串，那麼執行echo
# cmp是linux中的命令，語法是：cmp [-clsv][-i <字符數目>][--help][第一個文件][第二個文件]
# cmp的功能是：比較兩個文件是否有差異。
# echo也是linux中的命令，用於顯示字符串。語法是：echo [-ne][字符串]或 echo [--help][--version]
# rm也是linux中的命令，語法是：rm [選項]... 目錄... 作用是：刪除指定的<文件>(即解除鏈接)。
# Update vmlinux version before link
# Use + in front of this rule to silent warning about make -j1
# First command is ':' to allow us to use + in front of this rule
cmd_ksym_ld = $(cmd_vmlinux__)
define rule_ksym_ld
:
+$(call cmd,vmlinux_version)
$(call cmd,vmlinux__)
$(Q)echo 'cmd_$@ := $(cmd_vmlinux__)' > $(@D)/.$(@F).cmd
endef
# 爲變量cmd_ksym_ld賦值。
# 關鍵詞define定義了名叫rule_ksym_ld的命令包。
# 命令包rule_ksym_ld裏面的命令序列是define下面一行開始到endef上一行結束。
# 函數call的語法是:$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
# 函數call的功能是：<expression>;參數中的變量，被參數<parm1>;，<parm2>;，<parm3>;依次取代。
# 函數call的返回值是被取代後的<expression>。
# echo是linux中的命令，它的語法是：echo [-ne][字符串]或 echo [--help][--version]
# echo的功能是：echo會將輸入的字符串送往標準輸出。輸出的字符串間以空白字符隔開, 並在最後加上換行號。
# 符號>用來改變送出的數據信道(stdout, stderr)，使之輸出到指定的檔案。這裏是輸出到$(@D)/.$(@F).cmd。
# Generate .S file with all kernel symbols
quiet_cmd_kallsyms = KSYM $@
cmd_kallsyms = $(NM) -n $< | $(KALLSYMS) \
$(if $(CONFIG_KALLSYMS_ALL),--all-symbols) > $@
# 分別爲變量quiet_cmd_kallsyms和cmd_kallsyms賦值。
# 自動變量“$@”表示表示規則中的目標文件集，自動變量“$<”表示依賴目標中的第一個目標名字。
# 函數if的語法是；$(if <condition>;,<then-part>;,<else-part>;)，這裏沒有<then-part>。
# 如果<condition>爲非空字符串，於是<then-part>;會被計算。
# 符號>是linux中的重定向標誌。用來改變送出的數據信道(stdout, stderr)，使之輸出到指定的檔案；
# 符號|是linux中的管道標誌。功能是：上一個命令的 stdout 接到下一個命令的 stdin。
.tmp_kallsyms1.o .tmp_kallsyms2.o .tmp_kallsyms3.o: %.o: %.S scripts FORCE
$(call if_changed_dep,as_o_S)
# 定義了一個多目標規則。
# 函數call的語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
# 功能是：參數<expression>中的變量，被參數<parm1>;，<parm2>;，<parm3>;依次取代
# 返回值是：被替換後的<expression>。
.tmp_kallsyms%.S: .tmp_vmlinux% $(KALLSYMS)
$(call cmd,kallsyms)
# 定義了一個規則，目標爲.tmp_kallsyms%.S，依賴文件爲.tmp_vmlinux% $(KALLSYMS)。
# 函數call的語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
# 功能是：參數<expression>中的變量，被參數<parm1>;，<parm2>;，<parm3>;依次取代
# 返回值是：被替換後的<expression>。
# .tmp_vmlinux1 must be complete except kallsyms, so update vmlinux version
.tmp_vmlinux1: $(vmlinux-lds) $(vmlinux-all) FORCE
$(call if_changed_rule,ksym_ld)
# 定義了一個規則，目標爲.tmp_vmlinux1，依賴文件爲$(vmlinux-lds) $(vmlinux-all)。
# 函數call的語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
# 功能是：參數<expression>中的變量，被參數<parm1>;，<parm2>;，<parm3>;依次取代
# 返回值是：被替換後的<expression>。
.tmp_vmlinux2: $(vmlinux-lds) $(vmlinux-all) .tmp_kallsyms1.o FORCE
$(call if_changed,vmlinux__)
# 定義了一個規則，目標是.tmp_vmlinux2。
# 函數call的語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
# 功能是：參數<expression>中的變量，被參數<parm1>;，<parm2>;，<parm3>;依次取代
# 返回值是：被替換後的<expression>。
.tmp_vmlinux3: $(vmlinux-lds) $(vmlinux-all) .tmp_kallsyms2.o FORCE
$(call if_changed,vmlinux__)
# 定義了一個規則，目標是.tmp_vmlinux3
# # 函數call的語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
# 功能是：參數<expression>中的變量，被參數<parm1>;，<parm2>;，<parm3>;依次取代
# 返回值是：被替換後的<expression>。
# Needs to visit scripts/ before $(KALLSYMS) can be used.
$(KALLSYMS): scripts ;
# 定義了一個（分號前面沒有命令）沒有命令的規則，
# Generate some data for debugging strange kallsyms problems
debug_kallsyms: .tmp_map$(last_kallsyms)
# 定義了一個依賴關係，目標爲debug_kallsyms，依賴文件爲 .tmp_map$(last_kallsyms)
.tmp_map%: .tmp_vmlinux% FORCE
($(OBJDUMP) -h $< | $(AWK) '/^ +[0-9]/{print $$4 " 0 " $$2}'; $(NM) $<) | sort > $@
# 定義了一個規則，目標爲.tmp_map%，依賴文件爲.tmp_vmlinux%
# 自動化變量$<表示依賴目標中的目標文件集。自動化變量$@表示依賴目標中的第一個目標名字。
# 符號“|”表示管道，作用是：使上一個命令的stdout接到下一個命令的stdin。
# 符號“>”用來改變送出的數據信道，使之輸出到指定的檔案（文件等）。
.tmp_map3: .tmp_map2
# 定義了一個依賴關係，目標是.tmp_map3，依賴文件是.tmp_map2。
.tmp_map2: .tmp_map2
# 定義了一個依賴關係，目標是.tmp_map2，依賴文件是.tmp_map2。
endif # ifdef CONFIG_KALLSYMS
# 這個endif與ifdef CONFIG_KALLSYMS對應
# 定義了一個依賴關係，目標是.tmp_map3，依賴文件是.tmp_map2。
.tmp_map2: .tmp_map2
# 定義了一個依賴關係，目標是.tmp_map2，依賴文件是.tmp_map2。
endif # ifdef CONFIG_KALLSYMS
# 這個endif與ifdef CONFIG_KALLSYMS對應
# vmlinux image - including updated kernel symbols
vmlinux: $(vmlinux-lds) $(vmlinux-init) $(vmlinux-main) $(kallsyms.o) FORCE
ifdef CONFIG_HEADERS_CHECK
$(Q)$(MAKE) -f $(srctree)/Makefile headers_check
endif
$(call if_changed_rule,vmlinux__)
$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modpost $@
$(Q)rm -f .old_version
# 定義了一個規則，目標是vmlinux
# 條件關鍵詞ifdef的語法是：ifdef <variable-name>;
# 如果變量<variable-name>;的值非空，那到表達式爲真。否則，表達式爲假。
# 函數call的語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
# 函數call的功能是：<expression>;參數中的變量，被參數<parm1>;，<parm2>;，<parm3>;依次取代。
# rm是linux中的一個命令，-f是命令rm的參數，.old_version是要刪除的文件夾。
# The actual objects are generated when descending,
# make sure no implicit rule kicks in
$(sort $(vmlinux-init) $(vmlinux-main)) $(vmlinux-lds): $(vmlinux-dirs) ;
# 排序函數sort的語法是：$(sort <list>;)，
# 功能是：去掉<list>;中相同的單詞，然後給字符串<list>;中剩下的單詞排序（升序）。返回排好的字符串。
# Handle descending into subdirectories listed in $(vmlinux-dirs)
# Preset locale variables to speed up the build process. Limit locale
# tweaks to this spot to avoid wrong language settings when running
# make menuconfig etc.
# Error messages still appears in the original language
PHONY += $(vmlinux-dirs)
vmlinux-dirs: prepare scripts
$(Q)$(MAKE) $(build)=$@
# 爲變量PHONY追加變量vmlinux-dirs的值。
# 第二行定義了一個規則，目標是vmlinux-dirs，依賴文件是prepare和scripts。
# Build the kernel release string
#
# The KERNELRELEASE value built here is stored in the file
# include/config/kernel.release, and is used when executing several
# make targets, such as "make install" or "make modules_install."
#
# The eventual kernel release string consists of the following fields,
# shown in a hierarchical format to show how smaller parts are concatenated
# to form the larger and final value, with values coming from places like
# the Makefile, kernel config options, make command line options and/or
# SCM tag information.
#
# $(KERNELVERSION)
# $(VERSION) eg, 2
# $(PATCHLEVEL) eg, 6
# $(SUBLEVEL) eg, 18
# $(EXTRAVERSION) eg, -rc6
# $(localver-full)
# $(localver)
# localversion* (files without backups, containing '~')
# $(CONFIG_LOCALVERSION) (from kernel config setting)
# $(localver-auto) (only if CONFIG_LOCALVERSION_AUTO is set)
# ./scripts/setlocalversion (SCM tag, if one exists)
# $(LOCALVERSION) (from make command line if provided)
#
# Note how the final $(localver-auto) string is included *only* if the
# kernel config option CONFIG_LOCALVERSION_AUTO is selected. Also, at the
# moment, only git is supported but other SCMs can edit the script
# scripts/setlocalversion and add the appropriate checks as needed.
pattern = ".*/localversion[^~]*"
string = $(shell cat /dev/null \
`find $(objtree) $(srctree) -maxdepth 1 -regex $(pattern) | sort -u`)
# 爲變量pattern和string賦值
# 函數shell新生成一個shell程序來執行shell函數後面的命令（如cat、find等）
# cat是linux中的一個命令，語法是cat filename ，功能是一次顯示整個文件。
localver = $(subst $(space),, $(string) \
$(patsubst "%",%,$(CONFIG_LOCALVERSION)))
# 給變量localver賦值。
# subst是Makefile的一個字符串替換函數，語法是：$(subst <from>;,<to>;,<text>;)。
# 功能是：把字串<text>;中的<from>;字符串替換成<to>;，然後返回被替換過後的字符串。
# If CONFIG_LOCALVERSION_AUTO is set scripts/setlocalversion is called
# and if the SCM is know a tag from the SCM is appended.
# The appended tag is determined by the SCM used.
#
# Currently, only git is supported.
# Other SCMs can edit scripts/setlocalversion and add the appropriate
# checks as needed.
ifdef CONFIG_LOCALVERSION_AUTO
_localver-auto = $(shell $(CONFIG_SHELL) \
$(srctree)/scripts/setlocalversion $(srctree))
localver-auto = $(LOCALVERSION)$(_localver-auto)
endif
# ifdef是Makefile的一種條件關鍵字，語法是：ifdef <variable-name>;
# 功能是：如果變量<variable-name>;的值非空，那到表達式爲真。否則，表達式爲假。
# 如果變量<variable-name>;的值非空，則爲變量_localver-auto和localver-auto賦值。
localver-full = $(localver)$(localver-auto)
# 爲變量localver-full賦值。
# Store (new) KERNELRELASE string in include/config/kernel.release
kernelrelease = $(KERNELVERSION)$(localver-full)
include/config/kernel.release: include/config/auto.conf FORCE
$(Q)rm -f $@
$(Q)echo $(kernelrelease) > $@
# 爲變量kernelrelease賦值。
# 定義了一個規則，目標爲include/config/kernel.release，依賴文件爲include/config/auto.conf FORCE。
# rm是linux中的一個命令，語法是：rm [選項]... 目錄... ，功能是：目錄... 刪除指定的文件或目錄
# echo是linux下的一個命令，語法是：echo 字符串，功能是：將字符串送往標準輸出。
# Things we need to do before we recursively start building the kernel
# or the modules are listed in "prepare".
# A multi level approach is used. prepareN is processed before prepareN-1.
# archprepare is used in arch Makefiles and when processed asm symlink,
# version.h and scripts_basic is processed / created.
# Listed in dependency order
PHONY += prepare archprepare prepare0 prepare1 prepare2 prepare3
# 給變量PHONY追加值
# prepare3 is used to check if we are building in a separate output directory,
# and if so do:
# 1) Check that make has not been executed in the kernel src $(srctree)
# 2) Create the include2 directory, used for the second asm symlink
prepare3: include/config/kernel.release
ifneq ($(KBUILD_SRC),)
@echo ' Using $(srctree) as source for kernel'
$(Q)if [ -f $(srctree)/.config -o -d $(srctree)/include/config ]; then \
echo " $(srctree) is not clean, please run 'make mrproper'";\
echo " in the '$(srctree)' directory.";\
/bin/false; \
fi;
$(Q)if [ ! -d include2 ]; then mkdir -p include2; fi;
$(Q)ln -fsn $(srctree)/include/asm-$(ARCH) include2/asm
endif
# 定義了一個規則。目標是prepare3，依賴文件是include/config/kernel.release
# ifneq是Makefile的一個條件關鍵詞，語法是ifneq (<arg1>;, <arg2>;)
# 功能是:比較參數“arg1”和“arg2”的值是否相同，如果不同，則爲真，否則爲假。
# prepare2 creates a makefile if using a separate output directory
prepare2: prepare3 outputmakefile
# 定義了一個依賴關係。目標爲prepare2，依賴文件是：prepare3和outputmakefile
prepare1: prepare2 include/linux/version.h include/linux/utsrelease.h \
include/asm include/config/auto.conf
ifneq ($(KBUILD_MODULES),)
$(Q)mkdir -p $(MODVERDIR)
$(Q)rm -f $(MODVERDIR)/*
endif
# 定義了一個規則，目標爲prepare1。
# ifneq是Makefile的一個條件關鍵詞，其語法是：ifneq (<arg1>;, <arg2>;)
# 功能是:比較參數“arg1”和“arg2”的值是否相同，如果不同，則爲真，否則爲假。
# rm是linux shell中的一個用於刪除文件或文件夾的命令。
# 命令rm的語法是：rm [選項]... 文件...
archprepare: prepare1 scripts_basic
# 定義了一個依賴關係，目標是archprepare，依賴文件是prepare1 scripts_basic。
prepare0: archprepare FORCE
$(Q)$(MAKE) $(build)=.
$(Q)$(MAKE) $(build)=. missing-syscalls
# 定義了一個規則，目標是prepare0，依賴文件是archprepare FORCE
# All the preparing..
prepare: prepare0
# 定義了一個依賴關係，目標是prepare，依賴文件是prepare0
# Leave this as default for preprocessing vmlinux.lds.S, which is now
# done in arch/$(ARCH)/kernel/Makefile
export CPPFLAGS_vmlinux.lds += -P -C -U$(ARCH)
# 爲變量CPPFLAGS_vmlinux.lds追加值。
# export是Makefile的一個關鍵詞，用來聲明一個變量，使這個變量能傳到下級Makefile
# 語法是：export <variable ...>;
# FIXME: The asm symlink changes when $(ARCH) changes. That's
# hard to detect, but I suppose "make mrproper" is a good idea
# before switching between archs anyway.
include/asm:
@echo ' SYMLINK $@ -> include/asm-$(ARCH)'
$(Q)if [ ! -d include ]; then mkdir -p include; fi;
@ln -fsn asm-$(ARCH) $@
# 定義了一個僞目標include/asm
# 如果字符“@”在命令行前，那麼這個命令將不被make顯示出來。
# 通常make會把其要執行的命令行在命令執行前輸出到屏幕上。
# if是Makefile的一個函數，其語法是：$(if <condition>;,<then-part>;,<else-part>;)
# 功能是：。<condition>;參數是if的表達式，如果其返回的爲非空字符串，
# 那麼這個表達式就相當於返回真，於是，<then-part>;會被計算，否則<else-part>;會被計算。
# ln是linux shell中的一個命令，其語法是：ln [ -f | -n] [ -s ] SourceFile [ TargetFile ]
# 功能是：在 SourceFile 參數中指定的文件鏈接到在 TargetFile 參數中指定的文件。
# Generate some files
# ---------------------------------------------------------------------------
# KERNELRELEASE can change from a few different places, meaning version.h
# needs to be updated, so this check is forced on all builds
uts_len := 64
define filechk_utsrelease.h
if [ `echo -n "$(KERNELRELEASE)" | wc -c ` -gt $(uts_len) ]; then \
echo '"$(KERNELRELEASE)" exceeds $(uts_len) characters' >&2; \
exit 1; \
fi; \
(echo \#define UTS_RELEASE \"$(KERNELRELEASE)\";)
endef
# 第一行爲變量uts_len賦值。
# define是Makefile的一個關鍵字，用於定義命令包。此處定義了filechk_utsrelease.h命令包。
# echo是linux shell中的一個命令，它的語法是：echo [字符串]，功能是；將字符串送往標準輸出。
# 字符”|“是linux shell中的管道標誌，語法是：命令 | 命令，
# 功能是：前一個命令的輸出重定向到後一個命令的輸入
# 字符”\“是續行的標誌，由於某些命令要建立在前面的命令的基礎之上，
# 所以必須把它與前面的命令寫在同一行上，這時就要用到字符”\“來續行。
define filechk_version.h
(echo \#define LINUX_VERSION_CODE $(shell \
expr $(VERSION) \* 65536 + $(PATCHLEVEL) \* 256 + $(SUBLEVEL)); \
echo '#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))';)
endef
# export是Makefile的一個關鍵字，用來定義命令包（相同的命令序列定義一個變量，即命令包）。
# echo是linux shell中的一個命令，它的語法是：echo [字符串]，功能是；將字符串送往標準輸出。
# 字符”\“是續行的標誌，由於某些命令要建立在前面的命令的基礎之上，
# 所以必須把它與前面的命令寫在同一行上，這時就要用到字符”\“來續行。
# expr是linux shell中的一個字符串處理命令。
include/linux/version.h: $(srctree)/Makefile FORCE
$(call filechk,version.h)
# 定義了一個規則，目標是include/linux/version.h，依賴文件是$(srctree)/Makefile和FORCE
# call是Makefile中的一個命令，其語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
# 功能是：<expression>參數中的變量，如$(1)，$(2)，$(3)等，會被參數<parm1>，<parm2>，<parm3>依次取代。
include/linux/utsrelease.h: include/config/kernel.release FORCE
$(call filechk,utsrelease.h)
# 定義了一個規則，目標是include/linux/utsrelease.h，依賴文件是include/config/kernel.release和FORCE
# call是Makefile中的一個命令，其語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
# 功能是：<expression>;參數中的變量，如$(1)，$(2)，$(3)等，會被參數<parm1>，<parm2>，<parm3>依次取代。
# ---------------------------------------------------------------------------
PHONY += depend dep
depend dep:
@echo '*** Warning: make $@ is unnecessary now.'
# 第一行爲變量PHONY追加值depend和dep，第二行定義了僞目標depend dep。
# echo是linux shell中的一個命令，它的語法是：echo [字符串]，功能是；將字符串送往標準輸出。
# ---------------------------------------------------------------------------
# Kernel headers
INSTALL_HDR_PATH=$(objtree)/usr
export INSTALL_HDR_PATH
# 第一行爲變量INSTALL_HDR_PATH賦值。
# export是Makefile的一個關鍵字，用來聲明變量，使變量能傳到下級Makefile
HDRARCHES=$(filter-out generic,$(patsubst $(srctree)/include/asm-%/Kbuild,%,$(wildcard $(srctree)/include/asm-*/Kbuild)))
# 爲變量HDRARCHES賦值。
# filter-out是Makefile的一個字串處理函數。其語法是：$(filter-out <pattern...>;,<text>;)
# 功能是以<pattern>;模式過濾<text>;字符串中的單詞，去除符合模式<pattern>;的單詞。可以有多個模式。
# patsubst是Makefile中的模式字符串替換函數，其語法是：$(patsubst <pattern>;,<replacement>;,<text>;)
# 功能是：查找<text>;中的單詞是否符合模式<pattern>;，如果匹配的話，則以<replacement>;替換。
# wildcard是Makefile的一個關鍵字，在給變量賦值時，使通配符在變量中展開。
PHONY += headers_install_all
headers_install_all: include/linux/version.h scripts_basic FORCE
$(Q)$(MAKE) $(build)=scripts scripts/unifdef
$(Q)for arch in $(HDRARCHES); do \
$(MAKE) ARCH=$$arch -f $(srctree)/scripts/Makefile.headersinst obj=include BIASMDIR=-bi-$$arch ;\
done
# 第一行爲變量PHONY追加值
# 第二行定義了一個規則，目標是headers_install_all。
PHONY += headers_install
headers_install: include/linux/version.h scripts_basic FORCE
@if [ ! -r $(srctree)/include/asm-$(ARCH)/Kbuild ]; then \
echo '*** Error: Headers not exportable for this architecture ($(ARCH))'; \
exit 1 ; fi
$(Q)$(MAKE) $(build)=scripts scripts/unifdef
$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.headersinst obj=include
# 第一行爲變量PHONY追加值
# 第二行定義了一個規則，目標是headers_install。
PHONY += headers_check_all
headers_check_all: headers_install_all
$(Q)for arch in $(HDRARCHES); do \
$(MAKE) ARCH=$$arch -f $(srctree)/scripts/Makefile.headersinst obj=include BIASMDIR=-bi-$$arch HDRCHECK=1 ;\
done
# 第一行爲變量PHONY追加值
# 第二行定義了一個規則，目標是headers_check_all。
PHONY += headers_check
headers_check: headers_install
$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.headersinst obj=include HDRCHECK=1
# 第一行爲變量PHONY追加值
# 第二行定義了一個規則，目標是headers_check。
# ---------------------------------------------------------------------------
# Modules
ifdef CONFIG_MODULES
# ifdef是Makefile中的一個條件關鍵詞，其語法是：ifdef <variable-name>;
# 如果變量<variable-name>;的值非空，那到表達式爲真。否則，表達式爲假。
# By default, build modules as well
all: modules
# 定義了一個依賴關係，目標是all，依賴文件是modules
# Build modules
PHONY += modules
modules: $(vmlinux-dirs) $(if $(KBUILD_BUILTIN),vmlinux)
@echo ' Building modules, stage 2.';
$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modpost
# 爲變量PHONY追加值
# 定義了一個規則，目標是modules。
# if是Makefile中的一個函數，其語法是：$(if <condition>;,<then-part>;,<else-part>;)
# <condition>;參數是if的表達式，如果其返回的爲非空字符串，那麼這個表達式就相當於返回真，
# 於是，<then-part>;會被計算，否則<else-part>;會被計算。
# 當“@”字符在命令行前，那麼這個命令將不被make顯示出來。
# Target to prepare building external modules
PHONY += modules_prepare
modules_prepare: prepare scripts
# 爲變量PHONY追加值
# 第二行定義了依賴關係，目標是modules_prepare，依賴文件是prepare scripts
# Target to install modules
PHONY += modules_install
modules_install: _modinst_ _modinst_post
# 第一行爲變量追加值。
# 第二行定義了依賴關係，目標是modules_install，依賴文件是_modinst_ _modinst_post
PHONY += _modinst_
_modinst_:
@if [ -z "`$(DEPMOD) -V 2>/dev/null | grep module-init-tools`" ]; then \
echo "Warning: you may need to install module-init-tools"; \
echo "See http://www.codemonkey.org.uk/docs/post-halloween-2.6.txt";\
sleep 1; \
fi
@rm -rf $(MODLIB)/kernel
@rm -f $(MODLIB)/source
@mkdir -p $(MODLIB)/kernel
@ln -s $(srctree) $(MODLIB)/source
@if [ ! $(objtree) -ef $(MODLIB)/build ]; then \
rm -f $(MODLIB)/build ; \
ln -s $(objtree) $(MODLIB)/build ; \
fi
$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modinst
# 第一行爲變量PHONY追加值。
# 第二行定義了僞目標_modinst_。
# 當“@”字符在命令行前，那麼這個命令將不被make顯示出來。
# rm是linux shell中的用於刪除文件或目錄的命令。其語法是：rm [選項]... [要刪除的文件]...
# mkdir是linux shell中的用於創建目錄的命令，其語法是：mkdir [OPTION] DIRECTORY...
# ln是linux shell中的用於創建一個鏈接，其語法是：ln [OPTION]... [-T] TARGET LINK_NAME
# If System.map exists, run depmod. This deliberately does not have a
# dependency on System.map since that would run the dependency tree on
# vmlinux. This depmod is only for convenience to give the initial
# boot a modules.dep even before / is mounted read-write. However the
# boot script depmod is the master version.
ifeq "$(strip $(INSTALL_MOD_PATH))" ""
depmod_opts :=
else
depmod_opts := -b $(INSTALL_MOD_PATH) -r
endif
PHONY += _modinst_post
_modinst_post: _modinst_
if [ -r System.map -a -x $(DEPMOD) ]; then $(DEPMOD) -ae -F System.map $(depmod_opts) $(KERNELRELEASE); fi
# ifeq是Makefile中的一個條件關鍵詞，其語法是：ifeq "<arg1>;" "<arg2>;"
# strip是Makefile中的用於去掉空格的函數。其語法是：$(strip <string>;)
# 第二四行分別在不同的情況下給變量depmod_opts賦值。
# 第六行給變量PHONY追加值。
# 第七行定義了一個規則，目標是_modinst_post，依賴文件是_modinst_
else # CONFIG_MODULES
# 上面這個else與ifdef CONFIG_MODULES對應。
# Modules not configured
# ---------------------------------------------------------------------------
modules modules_install: FORCE
@echo
@echo "The present kernel configuration has modules disabled."
@echo "Type 'make config' and enable loadable module support."
@echo "Then build a kernel with module support enabled."
@echo
@exit 1
# 定義了一個規則，目標是modules modules_install，依賴文件是FORCE
# 當“@”字符在命令行前，那麼這個命令將不被make顯示出來。
# echo是Makefile中的一個將輸入的字符串送往標準輸出關鍵字，其語法是：echo [-ne][字符串]
# exit是linux shell中的一個退出目前的shell的命令，其語法是：exit [狀態值]
endif # CONFIG_MODULES
# 上面這個endif與ifdef CONFIG_MODULES對應。
###
# Cleaning is done on three levels.
# make clean Delete most generated files
# Leave enough to build external modules
# make mrproper Delete the current configuration, and all generated files
# make distclean Remove editor backup files, patch leftover files and the like
# Directories & files removed with 'make clean'
CLEAN_DIRS += $(MODVERDIR)
CLEAN_FILES += vmlinux System.map \
.tmp_kallsyms* .tmp_version .tmp_vmlinux* .tmp_System.map
# 第一行將變量MODVERDIR的值追加給變量CLEAN_DIRS
# 第二行給變量CLEAN_FILES追加值。
# Directories & files removed with 'make mrproper'
MRPROPER_DIRS += include/config include2 usr/include
MRPROPER_FILES += .config .config.old include/asm .version .old_version \
include/linux/autoconf.h include/linux/version.h \
include/linux/utsrelease.h \
Module.symvers tags TAGS cscope*
# 上面的是給變量MRPROPER_DIRS和MRPROPER_FILES追加值，
# 字符“\”有兩個功能：一是：續行；二是：轉義。
# clean - Delete most, but leave enough to build external modules
#
clean: rm-dirs := $(CLEAN_DIRS)
clean: rm-files := $(CLEAN_FILES)
clean-dirs := $(addprefix _clean_,$(srctree) $(vmlinux-alldirs))
# 第一二行分別定義了一個規則，每個規則的命令都是給依賴文件賦值。
# 第三行定義了一個依賴關係。
PHONY += $(clean-dirs) clean archclean
$(clean-dirs):
$(Q)$(MAKE) $(clean)=$(patsubst _clean_%,%,$@)
# 第一行給變量PHONY追加值。
# 第二行定義了一個僞目標$(clean-dirs)。
clean: archclean $(clean-dirs)
$(call cmd,rmdirs)
$(call cmd,rmfiles)
@find . $(RCS_FIND_IGNORE) \
\( -name '*.[oas]' -o -name '*.ko' -o -name '.*.cmd' \
-o -name '.*.d' -o -name '.*.tmp' -o -name '*.mod.c' \
-o -name '*.symtypes' \) \
-type f -print | xargs rm -f
# 第一行定義了一個規則，目標是clean，依賴文件是archclean和$(clean-dirs)
# call是Makefile的一個用來創建新的參數化的函數，
# 其語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
# <expression>;參數中的變量，會被參數<parm1>;，<parm2>;，<parm3>;依次取代。
# find是linux shell中的一個查找命令，其語法是：find path option [-print -exec -ok]
# 當“@”字符在命令行前，那麼這個命令將不被make顯示出來。
# 字符“\”有兩個功能：一是：續行；二是：轉義。
# mrproper - Delete all generated files, including .config
#
mrproper: rm-dirs := $(wildcard $(MRPROPER_DIRS))
mrproper: rm-files := $(wildcard $(MRPROPER_FILES))
mrproper-dirs := $(addprefix _mrproper_,Documentation/DocBook scripts)
# 第一二行分別定義了一個規則，它們的命令分別是給依賴文件賦值。
# 第三行給變量mrproper-dirs 賦值。
PHONY += $(mrproper-dirs) mrproper archmrproper
$(mrproper-dirs):
$(Q)$(MAKE) $(clean)=$(patsubst _mrproper_%,%,$@)
# 第一行給變量PHONY賦值。
# 第二行定義了一個僞目標$(mrproper-dirs)。
# patsubst是Makefile中的一個模式字符串替換函數，
# 其語法是：$(patsubst <pattern>;,<replacement>;,<text>;)
# 查找<text>;中的單詞是否符合模式<pattern>;，如果匹配的話，則以<replacement>;替換。
mrproper: clean archmrproper $(mrproper-dirs)
$(call cmd,rmdirs)
$(call cmd,rmfiles)
# 定義了一個規則，目標是mrproper。
# call是Makefile的一個用來創建新的參數化的函數，
# 其語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
# <expression>;參數中的變量，會被參數<parm1>;，<parm2>;，<parm3>;依次取代。
# distclean
#
PHONY += distclean
# 給變量PHONY追加值
distclean: mrproper
@find $(srctree) $(RCS_FIND_IGNORE) \
\( -name '*.orig' -o -name '*.rej' -o -name '*~' \
-o -name '*.bak' -o -name '#*#' -o -name '.*.orig' \
-o -name '.*.rej' -o -size 0 \
-o -name '*%' -o -name '.*.cmd' -o -name 'core' \) \
-type f -print | xargs rm -f
# 上面定義了一個規則，目標是distclean，依賴文件是mrproper。
# 當“@”字符在命令行前，那麼這個命令將不被make顯示出來。
# find是linux shell中的一個查找命令，其語法是：find path option [-print -exec -ok]
# 字符”\“有兩個用途：一是：轉義；二是：續行。
# Packaging of the kernel to various formats
# ---------------------------------------------------------------------------
# rpm target kept for backward compatibility
package-dir := $(srctree)/scripts/package
%pkg: include/config/kernel.release FORCE
$(Q)$(MAKE) $(build)=$(package-dir) $@
rpm: include/config/kernel.release FORCE
$(Q)$(MAKE) $(build)=$(package-dir) $@
# 上面定義了兩個規則，目標分別是%pkg和rpm。
@ $@是Makefile的自動化變量，表示當前規則的目標集。
# Brief documentation of the typical targets used
# ---------------------------------------------------------------------------
boards := $(wildcard $(srctree)/arch/$(ARCH)/configs/*_defconfig)
boards := $(notdir $(boards))
# 上面兩行分別給變量boards賦值。
# wildcard是Makefile中的關鍵字，用於讓通配符在變量中展開。
# notdir是Makefile中的取文件函數，其語法是：$(notdir <names...>;)
# 功能：從文件名序列<names>;中取出非目錄部分。非目錄部分是指最後一個反斜槓（“/”）之後的部分。
help:
@echo 'Cleaning targets:'
@echo ' clean - Remove most generated files but keep the config and'
@echo ' enough build support to build external modules'
@echo ' mrproper - Remove all generated files + config + various backup files'
@echo ' distclean - mrproper + remove editor backup and patch files'
@echo ''
@echo 'Configuration targets:'
@$(MAKE) -f $(srctree)/scripts/kconfig/Makefile help
@echo ''
@echo 'Other generic targets:'
@echo ' all - Build all targets marked with [*]'
@echo '* vmlinux - Build the bare kernel'
@echo '* modules - Build all modules'
@echo ' modules_install - Install all modules to INSTALL_MOD_PATH (default: /)'
@echo ' dir/ - Build all files in dir and below'
@echo ' dir/file.[ois] - Build specified target only'
@echo ' dir/file.ko - Build module including final link'
@echo ' rpm - Build a kernel as an RPM package'
@echo ' tags/TAGS - Generate tags file for editors'
@echo ' cscope - Generate cscope index'
@echo ' kernelrelease - Output the release version string'
@echo ' kernelversion - Output the version stored in Makefile'
@if [ -r $(srctree)/include/asm-$(ARCH)/Kbuild ]; then \
echo ' headers_install - Install sanitised kernel headers to INSTALL_HDR_PATH'; \
echo ' (default: $(INSTALL_HDR_PATH))'; \
fi
@echo ''
@echo 'Static analysers'
@echo ' checkstack - Generate a list of stack hogs'
@echo ' namespacecheck - Name space analysis on compiled kernel'
@if [ -r $(srctree)/include/asm-$(ARCH)/Kbuild ]; then \
echo ' headers_check - Sanity check on exported headers'; \
fi
@echo ''
@echo 'Kernel packaging:'
@$(MAKE) $(build)=$(package-dir) help
@echo ''
@echo 'Documentation targets:'
@$(MAKE) -f $(srctree)/Documentation/DocBook/Makefile dochelp
@echo ''
@echo 'Architecture specific targets ($(ARCH)):'
@$(if $(archhelp),$(archhelp),\
echo ' No architecture specific help defined for $(ARCH)')
@echo ''
@$(if $(boards), \
$(foreach b, $(boards), \
printf " %-24s - Build for %s\\n" $(b) $(subst _defconfig,,$(b));) \
echo '')
@echo ' make V=0|1 [targets] 0 => quiet build (default), 1 => verbose build'
@echo ' make V=2 [targets] 2 => give reason for rebuild of target'
@echo ' make O=dir [targets] Locate all output files in "dir", including .config'
@echo ' make C=1 [targets] Check all c source with $$CHECK (sparse by default)'
@echo ' make C=2 [targets] Force check of all c source with $$CHECK'
@echo ''
@echo 'Execute "make" or "make all" to build all targets marked with [*] '
@echo 'For further info see the ./README file'
# 第一行定義了一個僞目標help。
# 當“@”字符在命令行前，那麼這個命令將不被make顯示出來。
#
# Documentation targets
# ---------------------------------------------------------------------------
%docs: scripts_basic FORCE
# ---------------------------------------------------------------------------
%docs: scripts_basic FORCE
$(Q)$(MAKE) $(build)=Documentation/DocBook $@
# 定義了一個規則，目標是%docs，依賴關係是scripts_basic FORCE
# $@是Makefile的自動化變量，表示當前規則的目標集。
else # KBUILD_EXTMOD
###
# External module support.
# When building external modules the kernel used as basis is considered
# read-only, and no consistency checks are made and the make
# system is not used on the basis kernel. If updates are required
# in the basis kernel ordinary make commands (without M=...) must
# be used.
#
# The following are the only valid targets when building external
# modules.
# make M=dir clean Delete all automatically generated files
# make M=dir modules Make all modules in specified dir
# make M=dir Same as 'make M=dir modules'
# make M=dir modules_install
# Install the modules built in the module directory
# Assumes install directory is already created
# We are always building modules
KBUILD_MODULES := 1
PHONY += crmodverdir
crmodverdir:
$(Q)mkdir -p $(MODVERDIR)
$(Q)rm -f $(MODVERDIR)/*
# 第一行給變量KBUILD_MODULES賦值1.
# 第二行給變量PHONY追加值。
# 第三行定義了一個僞目標crmodverdir
# mkdir是linux shell下創建文件夾的命令，其語法是：mkdir [-p] dirName
# rm是linux shell下刪除文件或文件夾的命令，其語法是：rm [選項]... 文件...
PHONY += $(objtree)/Module.symvers
$(objtree)/Module.symvers:
@test -e $(objtree)/Module.symvers || ( \
echo; \
echo " WARNING: Symbol version dump $(objtree)/Module.symvers"; \
echo " is missing; modules will have no dependencies and modversions."; \
echo )
# 第一行給變量PHONY追加值。
# 第二行定義了一個爲目標$(objtree)/Module.symvers。
# 當“@”字符在命令行前，那麼這個命令將不被make顯示出來。
# echo是Makefile中的一個將輸入的字符串送往標準輸出關鍵字，其語法是：echo [-ne][字符串]
# test是linux shell下的一個對檔案偵測、判定的函數，其語法是：test [選項] string
# 字符“\”有兩個功能：一是：續行；二是：轉義。
module-dirs := $(addprefix _module_,$(KBUILD_EXTMOD))
PHONY += $(module-dirs) modules
$(module-dirs): crmodverdir $(objtree)/Module.symvers
$(Q)$(MAKE) $(build)=$(patsubst _module_%,%,$@)
# 第一行將函數addprefix的返回值展開後賦給變量module-dirs。
# 第二行給變量PHONY追加值。
# 第三行定義了一個規則，目標是$(module-dirs)，依賴文件是crmodverdir $(objtree)/Module.symvers
# addprefix是Makefile中的一個加前綴函數函數，其語法是：$(addprefix <prefix>;,<names...>;)
# patsubst是Makefile中的一個模式字符串替換函數，
# 其語法是：$(patsubst <pattern>;,<replacement>;,<text>;)
# 查找<text>;中的單詞是否符合模式<pattern>;，如果匹配的話，則以<replacement>;替換。
modules: $(module-dirs)
@echo ' Building modules, stage 2.';
$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modpost
# 上面定義了一個規則，目標是modules，依賴文件是$(module-dirs)。
# 當“@”字符在命令行前，那麼這個命令將不被make顯示出來。
# echo是Makefile中的一個將輸入的字符串送往標準輸出關鍵字，其語法是：echo [-ne][字符串]
PHONY += modules_install
modules_install: _emodinst_ _emodinst_post
# 第一行給變量PHONY追加值
# 第二行定義了一個依賴關係，目標是modules_install，依賴文件是_emodinst_ _emodinst_post
install-dir := $(if $(INSTALL_MOD_DIR),$(INSTALL_MOD_DIR),extra)
PHONY += _emodinst_
_emodinst_:
$(Q)mkdir -p $(MODLIB)/$(install-dir)
$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modinst
# 第一行將if函數的返回值展開後賦給變量install-dir。
# 第二行給變量PHONY追加值。
# 第三行定義了一個僞目標_emodinst_
# mkdir是linux shell下的一個創建文件夾的命令，其語法是：mkdir [-p] dirName
# Run depmod only is we have System.map and depmod is executable
quiet_cmd_depmod = DEPMOD $(KERNELRELEASE)
cmd_depmod = if [ -r System.map -a -x $(DEPMOD) ]; then \
$(DEPMOD) -ae -F System.map \
$(if $(strip $(INSTALL_MOD_PATH)), \
-b $(INSTALL_MOD_PATH) -r) \
$(KERNELRELEASE); \
fi
# 第一二行分別給變量quiet_cmd_depmod和cmd_depmod賦值。
# strip是Makefile中的去空格函數，其語法是：$(strip <string>;)
# 字符“\”有兩個功能：一是：續行；二是：轉義。
PHONY += _emodinst_post
_emodinst_post: _emodinst_
$(call cmd,depmod)
# 第一行給變量PHONY追加值。
# 第二行定義了一個規則，目標是_emodinst_post，依賴文件是_emodinst_
# call是Makefile中一個用來創建新的參數化的函數，
# 其語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
# <expression>;參數中的變量，會被參數<parm1>;，<parm2>;，<parm3>;依次取代。
clean-dirs := $(addprefix _clean_,$(KBUILD_EXTMOD))
# 上面將函數addprefix的返回值展開後賦給變量clean-dirs。
# addprefix是Makefile中一個加前綴函數，其語法是：$(addprefix <prefix>;,<names...>;)
# 功能：把前綴<prefix>;加到<names>;中的每個單詞後面。
PHONY += $(clean-dirs) clean
$(clean-dirs):
$(Q)$(MAKE) $(clean)=$(patsubst _clean_%,%,$@)
# 第一行給變量PHONY追加值。
# 第二行定義了一個爲目標$(clean-dirs)，
# patsubst是Makefile中的一個模式字符串替換函數，
# 其語法是：$(patsubst <pattern>;,<replacement>;,<text>;)
# 查找<text>;中的單詞是否符合模式<pattern>;，如果匹配的話，則以<replacement>;替換。
clean: rm-dirs := $(MODVERDIR)
clean: $(clean-dirs)
$(call cmd,rmdirs)
@find $(KBUILD_EXTMOD) $(RCS_FIND_IGNORE) \
\( -name '*.[oas]' -o -name '*.ko' -o -name '.*.cmd' \
-o -name '.*.d' -o -name '.*.tmp' -o -name '*.mod.c' \) \
-type f -print | xargs rm -f
# 第一行定義了一個規則，目標是clean，依賴文件是rm-dirs，命令是給依賴文件rm-dirs賦值
# call是Makefile中一個用來創建新的參數化的函數，
# 當“@”字符在命令行前，那麼這個命令將不被make顯示出來。
# find是linux shell下的一個查找命令，其語法是：find path option [-print -exec -ok]
# 字符“\”有兩個功能：一是：續行；二是：轉義。
help:
@echo ' Building external modules.'
@echo ' Syntax: make -C path/to/kernel/src M=$$PWD target'
@echo ''
@echo ' modules - default target, build the module(s)'
@echo ' modules_install - install the module'
@echo ' clean - remove generated files in module directory only'
@echo ''
# 上面定義了一個僞目標help。
# 當“@”字符在命令行前，那麼這個命令將不被make顯示出來。
# echo是Makefile中的一個將輸入的字符串送往標準輸出關鍵字，其語法是：echo [-ne][字符串]
# Dummies...
PHONY += prepare scripts
prepare: ;
scripts: ;
endif # KBUILD_EXTMOD
# 第一行給變量PHONY追加值
# 第二三行分別定義了一個爲目標，命令爲空命令。
# Generate tags for editors
# ---------------------------------------------------------------------------
#We want __srctree to totally vanish out when KBUILD_OUTPUT is not set
#(which is the most common case IMHO) to avoid unneeded clutter in the big tags file.
#Adding $(srctree) adds about 20M on i386 to the size of the output file!
ifeq ($(src),$(obj))
__srctree =
else
__srctree = $(srctree)/
endif
# ifeq是Makefile中的一個條件關鍵字，其語法是：ifeq (<arg1>;, <arg2>;)
# 功能：比較參數“arg1”和“arg2”的值是否相同。
ifeq ($(ALLSOURCE_ARCHS),)
ifeq ($(ARCH),um)
ALLINCLUDE_ARCHS := $(ARCH) $(SUBARCH)
else # 這個else與ifeq ($(ARCH),um)對應。
ALLINCLUDE_ARCHS := $(ARCH)
endif # 這個endif與ifeq ($(ARCH),um)對應。
else # 這個else與外層的ifeq ($(ALLSOURCE_ARCHS),)對應
#Allow user to specify only ALLSOURCE_PATHS on the command line, keeping existing behavour.
ALLINCLUDE_ARCHS := $(ALLSOURCE_ARCHS)
endif # 這個endif與外層的ifeq ($(ALLSOURCE_ARCHS),)對應
# ifeq是Makefile中的一個條件關鍵字，其語法是：ifeq (<arg1>;, <arg2>;)
# 功能：比較參數“arg1”和“arg2”的值是否相同。
# 上面在ifeq ($(ALLSOURCE_ARCHS),)裏面嵌入了一個ifeq ($(ARCH),um)。
ALLSOURCE_ARCHS := $(ARCH)
# 給變量ALLSOURCE_ARCHS賦值
define find-sources
( for ARCH in $(ALLSOURCE_ARCHS) ; do \
find $(__srctree)arch/$${ARCH} $(RCS_FIND_IGNORE) \
-name $1 -print; \
done ; \
find $(__srctree)security/selinux/include $(RCS_FIND_IGNORE) \
-name $1 -print; \
find $(__srctree)include $(RCS_FIND_IGNORE) \
\( -name config -o -name 'asm-*' \) -prune \
-o -name $1 -print; \
for ARCH in $(ALLINCLUDE_ARCHS) ; do \
find $(__srctree)include/asm-$${ARCH} $(RCS_FIND_IGNORE) \
-name $1 -print; \
done ; \
find $(__srctree)include/asm-generic $(RCS_FIND_IGNORE) \
-name $1 -print; \
find $(__srctree) $(RCS_FIND_IGNORE) \
\( -name include -o -name arch \) -prune -o \
-name $1 -print; \
)
endef
# define是Makefile中的一個定義命令包（相同的命令序列）的關鍵字，
# find是linux shell下的一個查找命令，其語法是：find path option [-print -exec -ok]
# 字符“\”有兩個功能：一是：續行；二是：轉義。
define all-sources
$(call find-sources,'*.[chS]')
endef
define all-kconfigs
$(call find-sources,'Kconfig*')
endef
define all-defconfigs
$(call find-sources,'defconfig')
endef
# define是Makefile中的一個定義命令包（相同的命令序列）的關鍵字，
# call是Makefile中的唯一一個來創建新的參數化的函數，
# 其語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
# <expression>;參數中的變量，會被參數<parm1>;，<parm2>;，<parm3>;依次取代。
define xtags
if $1 --version 2>&1 | grep -iq exuberant; then \
$(all-sources) | xargs $1 -a \
-I __initdata,__exitdata,__acquires,__releases \
-I EXPORT_SYMBOL,EXPORT_SYMBOL_GPL \
--extra=+f --c-kinds=+px \
--regex-asm='/ENTRY\(([^)]*)\).*/\1/'; \
$(all-kconfigs) | xargs $1 -a \
--langdef=kconfig \
--language-force=kconfig \
--regex-kconfig='/^[[:blank:]]*config[[:blank:]]+([[:alnum:]_]+)/\1/'; \
$(all-defconfigs) | xargs -r $1 -a \
--langdef=dotconfig \
--language-force=dotconfig \
--regex-dotconfig='/^#?[[:blank:]]*(CONFIG_[[:alnum:]_]+)/\1/'; \
elif $1 --version 2>&1 | grep -iq emacs; then \
$(all-sources) | xargs $1 -a; \
$(all-kconfigs) | xargs $1 -a \
--regex='/^[ \t]*config[ \t]+\([a-zA-Z0-9_]+\)/\1/'; \
$(all-defconfigs) | xargs -r $1 -a \
--regex='/^#?[ \t]?\(CONFIG_[a-zA-Z0-9_]+\)/\1/'; \
else \
$(all-sources) | xargs $1 -a; \
fi
endef
# define是Makefile中的一個定義命令包（相同的命令序列）的關鍵字，
# 字符“\”有兩個功能：一是：續行；二是：轉義。
# 字符“|”是管道的標誌，它的作用是：將上一個命令的stdout重定向到下一個命令的stdin。
# grep是linux shell中一個在文件中查找字符串的命令。其語法是：grep 字符串 文件名
# xargs是linux shell中的一個對輸出執行其他某些命令的命令。
quiet_cmd_cscope-file = FILELST cscope.files
cmd_cscope-file = (echo \-k; echo \-q; $(all-sources)) > cscope.files
# 第一二行分別給變量quiet_cmd_cscope-file、cmd_cscope-file 賦值。
# echo是Makefile中的一個將輸入的字符串送往標準輸出關鍵字，其語法是：echo [-ne][字符串]
# 字符“\”有兩個功能：一是：續行；二是：轉義。
# 字符“>”是重定向標誌，功能將前一個命令的stdou重定向到檔案（文件等）。
quiet_cmd_cscope = MAKE cscope.out
cmd_cscope = cscope -b
# 分別給變量quiet_cmd_cscope和cmd_cscope賦值。
cscope: FORCE
$(call cmd,cscope-file)
$(call cmd,cscope)
# 上面定義了一個規則，目標是cscope，依賴文件是FORCE。
# call是Makefile中的唯一一個來創建新的參數化的函數，
# 其語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
quiet_cmd_TAGS = MAKE $@
define cmd_TAGS
rm -f $@; \
$(call xtags,etags)
endef
# 第一行給變量quiet_cmd_TAGS賦值。
# $@是Makefile的自動化變量，它代表當前規則的目標文件集。
# define是Makefile中的一個定義命令包（相同的命令序列）的關鍵字，
# rm是linux shell下刪除文件或文件夾的命令，其語法是：rm [選項]... 文件...
# call是Makefile中的唯一一個來創建新的參數化的函數，
# 其語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
TAGS: FORCE
$(call cmd,TAGS)
# 上面定義了一個規則，目標是TAGS，依賴文件是FORCE。
# call是Makefile中的唯一一個來創建新的參數化的函數，
# 其語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
quiet_cmd_tags = MAKE $@
define cmd_tags
rm -f $@; \
$(call xtags,ctags)
endef
# 第一行給變量quiet_cmd_tags賦值。
# $@是Makefile的自動化變量，它代表當前規則的目標文件集。
# define是Makefile中的一個定義命令包（相同的命令序列）的關鍵字，
# rm是linux shell下刪除文件或文件夾的命令，其語法是：rm [選項]... 文件...
# call是Makefile中的唯一一個來創建新的參數化的函數，
# 其語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
tags: FORCE
$(call cmd,tags)
# 上面定義了一個規則，目標是tags，依賴文件是FORCE
# call是Makefile中的唯一一個來創建新的參數化的函數，
# 其語法是：$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
# Scripts to check various things for consistency
# ---------------------------------------------------------------------------
# Scripts to check various things for consistency
# ---------------------------------------------------------------------------
includecheck:
find * $(RCS_FIND_IGNORE) \
-name '*.[hcS]' -type f -print | sort \
| xargs $(PERL) -w scripts/checkincludes.pl
# 第一行定義了一個僞目標includecheck
# find是linux shell下的一個查找命令，其語法是：find path option [-print -exec -ok]
# 字符“\”有兩個功能：一是：續行；二是：轉義。
# 字符“|”是管道的標誌，它的作用是：將上一個命令的stdout重定向到下一個命令的stdin。
# xargs是linux shell中的一個對輸出執行其他某些命令的命令。
versioncheck:
find * $(RCS_FIND_IGNORE) \
-name '*.[hcS]' -type f -print | sort \
| xargs $(PERL) -w scripts/checkversion.pl
# 第一行定義了一個僞目標versioncheck
# find是linux shell下的一個查找命令，其語法是：find path option [-print -exec -ok]
# 字符“\”有兩個功能：一是：續行；二是：轉義。
# 字符“|”是管道的標誌，它的作用是：將上一個命令的stdout重定向到下一個命令的stdin。
# xargs是linux shell中的一個對輸出執行其他某些命令的命令。
namespacecheck:
$(PERL) $(srctree)/scripts/namespace.pl
# 上面定義了一個僞目標namespacecheck
endif #ifeq ($(config-targets),1)
endif #ifeq ($(mixed-targets),1)
# 上面第一個endif與ifeq ($(config-targets),1)對應
# 上面第二個endif與ifeq ($(mixed-targets),1)對應
PHONY += checkstack kernelrelease kernelversion
# 給變量PHONY追加值
# UML needs a little special treatment here. It wants to use the host
# toolchain, so needs $(SUBARCH) passed to checkstack.pl. Everyone
# else wants $(ARCH), including people doing cross-builds, which means
# that $(SUBARCH) doesn't work here.
ifeq ($(ARCH), um)
CHECKSTACK_ARCH := $(SUBARCH)
else
CHECKSTACK_ARCH := $(ARCH)
endif
checkstack:
$(OBJDUMP) -d vmlinux $$(find . -name '*.ko') | \
$(PERL) $(src)/scripts/checkstack.pl $(CHECKSTACK_ARCH)
# ifeq是Makefile中的一個條件關鍵字，其語法是：ifeq (<arg1>;, <arg2>;)
# 功能：比較參數“arg1”和“arg2”的值是否相同。
# 第二四行分別在不同的情況下給變量CHECKSTACK_ARCH賦值
# 第六行定義了一個僞目標checkstack。
# 字符“\”有兩個功能：一是：續行；二是：轉義。
# 字符“|”是管道的標誌，它的作用是：將上一個命令的stdout重定向到下一個命令的stdin。
kernelrelease:
$(if $(wildcard include/config/kernel.release), $(Q)echo $(KERNELRELEASE), \
$(error kernelrelease not valid - run 'make prepare' to update it))
kernelversion:
@echo $(KERNELVERSION)
# 第一四行分別定義了一個僞目標。
# if是Makefile中函數。其語法是：$(if <condition>;,<then-part>;,<else-part>;)
# <condition>;參數是if的表達式，如果其返回的爲非空字符串，
# 那麼這個表達式就相當於返回真，於是，<then-part>;會被計算，否則<else-part>;會被計算。
# 當“@”字符在命令行前，那麼這個命令將不被make顯示出來。
# echo是Makefile中的一個將輸入的字符串送往標準輸出關鍵字，其語法是：echo [-ne][字符串]
# Single targets
# ---------------------------------------------------------------------------
# Single targets are compatible with:
# - build whith mixed source and output
# - build with separate output dir 'make O=...'
# - external modules
#
# target-dir => where to store outputfile
# build-dir => directory in kernel source tree to use
ifeq ($(KBUILD_EXTMOD),)
build-dir = $(patsubst %/,%,$(dir $@))
target-dir = $(dir $@)
else
zap-slash=$(filter-out .,$(patsubst %/,%,$(dir $@)))
build-dir = $(KBUILD_EXTMOD)$(if $(zap-slash),/$(zap-slash))
target-dir = $(if $(KBUILD_EXTMOD),$(dir $<),$(dir $@))
endif
# ifeq是Makefile中的一個條件關鍵字，其語法是：ifeq (<arg1>;, <arg2>;)
# 功能：比較參數“arg1”和“arg2”的值是否相同。
# patsubst是Makefile中的模式字符串替換函數，其語法是：$(patsubst <pattern>;,<replacement>;,<text>;)
# 功能：查找<text>;中的單詞是否符合模式<pattern>;，如果匹配的話，則以<replacement>;替換。
# filter-out是Makefile中的反過濾函數，其語法是：$(filter-out <pattern...>;,<text>;)
# 功能：以<pattern>;模式過濾<text>;字符串中的單詞，去除符合模式<pattern>;的單詞。可以有多個模式。
# if是Makefile中函數。其語法是：$(if <condition>;,<then-part>;,<else-part>;)
%.s: %.c prepare scripts FORCE
$(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@)
%.i: %.c prepare scripts FORCE
$(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@)
%.o: %.c prepare scripts FORCE
$(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@)
%.lst: %.c prepare scripts FORCE
$(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@)
%.s: %.S prepare scripts FORCE
$(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@)
%.o: %.S prepare scripts FORCE
$(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@)
%.symtypes: %.c prepare scripts FORCE
$(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@)
# 上面定義了一系列的規則。
# Modules
/ %/: prepare scripts FORCE
$(Q)$(MAKE) KBUILD_MODULES=$(if $(CONFIG_MODULES),1) \
$(build)=$(build-dir)
%.ko: prepare scripts FORCE
$(Q)$(MAKE) KBUILD_MODULES=$(if $(CONFIG_MODULES),1) \
$(build)=$(build-dir) $(@:.ko=.o)
$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modpost
# 上面第一四行分別定義了一個規則。
# if是Makefile中函數。其語法是：$(if <condition>;,<then-part>;,<else-part>;)
# FIXME Should go into a make.lib or something
# ===========================================================================
quiet_cmd_rmdirs = $(if $(wildcard $(rm-dirs)),CLEAN $(wildcard $(rm-dirs)))
cmd_rmdirs = rm -rf $(rm-dirs)
# 上面兩行分別給變量quiet_cmd_rmdirs和cmd_rmdirs賦值
# if是Makefile中函數。其語法是：$(if <condition>;,<then-part>;,<else-part>;)
# rm是linux shell中的刪除文件或文件夾的命令，語法是：rm [選項] 文件[或文件夾]
quiet_cmd_rmfiles = $(if $(wildcard $(rm-files)),CLEAN $(wildcard $(rm-files)))
cmd_rmfiles = rm -f $(rm-files)
# 上面兩行分別給變量quiet_cmd_rmfiles和cmd_rmfiles賦值
# if是Makefile中函數。其語法是：$(if <condition>;,<then-part>;,<else-part>;)
# rm是linux shell中的刪除文件或文件夾的命令，語法是：rm [選項] 文件[或文件夾]
a_flags = -Wp,-MD,$(depfile) $(AFLAGS) $(AFLAGS_KERNEL) \
$(NOSTDINC_FLAGS) $(CPPFLAGS) \
$(modkern_aflags) $(EXTRA_AFLAGS) $(AFLAGS_$(basetarget).o)
# 第一行給變量a_flags賦值
# 第二三行是命令，命令都是以tab開頭的。
quiet_cmd_as_o_S = AS $@
cmd_as_o_S = $(CC) $(a_flags) -c -o $@ $<
# 上面兩行分別給變量quiet_cmd_as_o_S和cmd_as_o_S賦值。
# $@和$<都是Makefile中的自動化變量，$@表示當前規則中的目標文件集，$<表示依賴目標中的第一個目標名字。
# read all saved command lines
targets := $(wildcard $(sort $(targets)))
cmd_files := $(wildcard .*.cmd $(foreach f,$(targets),$(dir $(f)).$(notdir $(f)).cmd))
# 上面兩行分別給變量targets和cmd_files賦值
# sort是Makefile中的一個排序（升序）函數，其語法是：$(sort <list>;)
# wildcard是Makefile中的關鍵字，它的作用是讓通配符在變量中展開。
# foreach是Makefile中的循環函數，其語法是：$(foreach <var>;,<list>;,<text>;)
# dir是Makefile中的取目錄函數，其語法是：$(dir <names...>;)
# 功能：從文件名序列<names>;中取出目錄部分，即最後一個反斜槓（“/”）之前的部分。若沒有反斜槓則返回“./”。
ifneq ($(cmd_files),)
$(cmd_files): ; # Do not try to update included dependency files
include $(cmd_files)
endif
# ifeq是Makefile中的一個條件關鍵字，其語法是：ifeq (<arg1>;, <arg2>;)
# 功能：比較參數“arg1”和“arg2”的值是否相同。
# include是Makefile中的關鍵字，其語法是：include <filename>;
# 把別的Makefile包含進來，這很像C語言的#include，被包含的文件會原模原樣的放在當前文件的包含位置。
# Shorthand for $(Q)$(MAKE) -f scripts/Makefile.clean obj=dir
# Usage:
# $(Q)$(MAKE) $(clean)=dir
clean := -f $(if $(KBUILD_SRC),$(srctree)/)scripts/Makefile.clean obj
# 上面這一行是給變量clean賦值
# if是Makefile中函數。其語法是：$(if <condition>;,<then-part>;,<else-part>;)
endif # skip-makefile
PHONY += FORCE
FORCE:
# 第一行給變量PHONY追加值
# 第二行定義了一個僞目標FORCE
# Cancel implicit rules on top Makefile, `-rR' will apply to sub-makes.
Makefile: ;
# 上面這一行定義了一個僞目標Makefile，命令爲空
# Declare the contents of the .PHONY variable as phony. We keep that
# information in a variable se we can use it in if_changed and friends.
.PHONY: $(PHONY)
# 上面這一行定義了一個依賴關係。