linux-yocto/Makefile

SPDX-License-Identifier: GPL-2.0

VERSION = 4 PATCHLEVEL = 14 SUBLEVEL = 202 EXTRAVERSION = NAME = Petit Gorille

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.

That's our default target when none is given on the command line

PHONY := _all _all:

o Do not use make's built-in rules and variables

(this increases performance and avoids hard-to-debug behaviour);

o Look for make include files relative to root of kernel src

MAKEFLAGS += -rR --include-dir=$(CURDIR)

Avoid funny character set dependencies

unexport LC_ALL LC_COLLATE=C LC_NUMERIC=C export LC_COLLATE LC_NUMERIC

Avoid interference with shell env settings

unexport GREP_OPTIONS

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.

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.

To put more focus on warnings, be less verbose as default

Use 'make V=1' to see the full commands

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

If the user is running make -s (silent mode), suppress echoing of

commands

ifneq ($(findstring s,$(filter-out --%,$(MAKEFLAGS))),) quiet=silent_ tools_silent=s endif

export quiet Q KBUILD_VERBOSE

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 not intended to be used by the regular user (for now),

it is set on invocation of make with KBUILD_OUTPUT or O= specified.

ifeq ($(KBUILD_SRC),)

OK, Make called in directory where kernel src resides

Do we want to locate output files in a separate directory?

ifeq ("$(origin O)", "command line") KBUILD_OUTPUT := $(O) endif

Cancel implicit rules on top Makefile

$(CURDIR)/Makefile Makefile: ;

ifneq ($(words $(subst :, ,$(CURDIR))), 1) $(error main directory cannot contain spaces nor colons) endif

ifneq ($(KBUILD_OUTPUT),)

check that the output directory actually exists

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)"))

PHONY += $(MAKECMDGOALS) sub-make

$(filter-out _all sub-make $(CURDIR)/Makefile, $(MAKECMDGOALS)) _all: sub-make @:

Invoke a second make in the output directory, passing relevant variables

sub-make: $(Q)$(MAKE) -C $(KBUILD_OUTPUT) KBUILD_SRC=$(CURDIR)
-f $(CURDIR)/Makefile $(filter-out _all sub-make,$(MAKECMDGOALS))

Leave processing to above invocation of make

skip-makefile := 1 endif # ifneq ($(KBUILD_OUTPUT),) endif # ifeq ($(KBUILD_SRC),)

We process the rest of the Makefile if this is the final invocation of make

ifeq ($(skip-makefile),)

Do not print "Entering directory ...",

but we want to display it when entering to the output directory

so that IDEs/editors are able to understand relative filenames.

MAKEFLAGS += --no-print-directory

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/dev-tools/sparse.rst" for more details,

including where to get the "sparse" utility.

ifeq ("$(origin C)", "command line") KBUILD_CHECKSRC = $(C) endif ifndef KBUILD_CHECKSRC KBUILD_CHECKSRC = 0 endif

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

ifeq ("$(origin M)", "command line") KBUILD_EXTMOD := $(M) endif

ifeq ($(KBUILD_SRC),) # building in the source tree srctree := . else ifeq ($(KBUILD_SRC)/,$(dir $(CURDIR))) # building in a subdirectory of the source tree srctree := .. else srctree := $(KBUILD_SRC) endif endif

export KBUILD_CHECKSRC KBUILD_EXTMOD KBUILD_SRC

objtree := . src := $(srctree) obj := $(objtree)

VPATH := $(srctree)$(if $(KBUILD_EXTMOD),:$(KBUILD_EXTMOD))

export srctree objtree VPATH

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).

version_h := include/generated/uapi/linux/version.h old_version_h := include/linux/version.h

no-dot-config-targets := clean mrproper distclean
cscope gtags TAGS tags help% %docs check% coccicheck
$(version_h) headers_% archheaders archscripts
kernelversion %src-pkg

config-targets := 0 mixed-targets := 0 dot-config := 1

ifneq ($(filter $(no-dot-config-targets), $(MAKECMDGOALS)),) ifeq ($(filter-out $(no-dot-config-targets), $(MAKECMDGOALS)),) dot-config := 0 endif endif

ifeq ($(KBUILD_EXTMOD),) ifneq ($(filter config %config,$(MAKECMDGOALS)),) config-targets := 1 ifneq ($(words $(MAKECMDGOALS)),1) mixed-targets := 1 endif endif endif

install and modules_install need also be processed one by one

ifneq ($(filter install,$(MAKECMDGOALS)),) ifneq ($(filter modules_install,$(MAKECMDGOALS)),) mixed-targets := 1 endif endif

ifeq ($(mixed-targets),1)

===========================================================================

We're called with mixed targets (*config and build targets).

Handle them one by one.

PHONY += $(MAKECMDGOALS) __build_one_by_one

$(filter-out __build_one_by_one, $(MAKECMDGOALS)): __build_one_by_one @:

__build_one_by_one: $(Q)set -e;
for i in $(MAKECMDGOALS); do
$(MAKE) -f $(srctree)/Makefile $$i;
done

else

We need some generic definitions (do not try to remake the file).

scripts/Kbuild.include: ; include scripts/Kbuild.include

Read KERNELRELEASE from include/config/kernel.release (if it exists)

KERNELRELEASE = $(shell cat include/config/kernel.release 2> /dev/null) KERNELVERSION = $(VERSION)$(if $(PATCHLEVEL),.$(PATCHLEVEL)$(if $(SUBLEVEL),.$(SUBLEVEL)))$(EXTRAVERSION) export VERSION PATCHLEVEL SUBLEVEL KERNELRELEASE KERNELVERSION

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/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/ )

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.

A third alternative is to store a setting in .config so that plain

"make" in the configured kernel build directory always uses that.

Default value for CROSS_COMPILE is not to prefix executables

Note: Some architectures assign CROSS_COMPILE in their arch/*/Makefile

ARCH ?= $(SUBARCH) CROSS_COMPILE ?= $(CONFIG_CROSS_COMPILE:"%"=%)

Architecture as present in compile.h

UTS_MACHINE := $(ARCH) SRCARCH := $(ARCH)

Additional ARCH settings for x86

ifeq ($(ARCH),i386) SRCARCH := x86 endif ifeq ($(ARCH),x86_64) SRCARCH := x86 endif

Additional ARCH settings for sparc

ifeq ($(ARCH),sparc32) SRCARCH := sparc endif ifeq ($(ARCH),sparc64) SRCARCH := sparc endif

Additional ARCH settings for sh

ifeq ($(ARCH),sh64) SRCARCH := sh endif

Additional ARCH settings for tile

ifeq ($(ARCH),tilepro) SRCARCH := tile endif ifeq ($(ARCH),tilegx) SRCARCH := tile endif

Where to locate arch specific headers

hdr-arch := $(SRCARCH)

KCONFIG_CONFIG ?= .config export 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)

HOST_LFS_CFLAGS := $(shell getconf LFS_CFLAGS 2>/dev/null) HOST_LFS_LDFLAGS := $(shell getconf LFS_LDFLAGS 2>/dev/null) HOST_LFS_LIBS := $(shell getconf LFS_LIBS 2>/dev/null)

HOSTCC = gcc HOSTCXX = g++ HOSTCFLAGS := -Wall -Wmissing-prototypes -Wstrict-prototypes -O2
-fomit-frame-pointer -std=gnu89 $(HOST_LFS_CFLAGS) HOSTCXXFLAGS := -O2 $(HOST_LFS_CFLAGS) HOSTLDFLAGS := $(HOST_LFS_LDFLAGS) HOST_LOADLIBES := $(HOST_LFS_LIBS)

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 INSTALLKERNEL := installkernel DEPMOD = /sbin/depmod PERL = perl PYTHON = python CHECK = sparse

CHECKFLAGS := -D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__
-Wbitwise -Wno-return-void $(CF) NOSTDINC_FLAGS = CFLAGS_MODULE = AFLAGS_MODULE = LDFLAGS_MODULE = CFLAGS_KERNEL = AFLAGS_KERNEL = LDFLAGS_vmlinux =

Use USERINCLUDE when you must reference the UAPI directories only.

USERINCLUDE :=
-I$(srctree)/arch/$(hdr-arch)/include/uapi
-I$(objtree)/arch/$(hdr-arch)/include/generated/uapi
-I$(srctree)/include/uapi
-I$(objtree)/include/generated/uapi
-include $(srctree)/include/linux/kconfig.h

Use LINUXINCLUDE when you must reference the include/ directory.

Needed to be compatible with the O= option

LINUXINCLUDE :=
-I$(srctree)/arch/$(hdr-arch)/include
-I$(objtree)/arch/$(hdr-arch)/include/generated
$(if $(KBUILD_SRC), -I$(srctree)/include)
-I$(objtree)/include
$(USERINCLUDE)

KBUILD_AFLAGS := -D__ASSEMBLY__ KBUILD_CFLAGS := -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs
-fno-strict-aliasing -fno-common -fshort-wchar
-Werror-implicit-function-declaration
-Wno-format-security
-std=gnu89 KBUILD_CPPFLAGS := -D__KERNEL__ KBUILD_AFLAGS_KERNEL := KBUILD_CFLAGS_KERNEL := KBUILD_AFLAGS_MODULE := -DMODULE KBUILD_CFLAGS_MODULE := -DMODULE KBUILD_LDFLAGS_MODULE := -T $(srctree)/scripts/module-common.lds GCC_PLUGINS_CFLAGS := CLANG_FLAGS :=

export ARCH SRCARCH CONFIG_SHELL HOSTCC HOSTCFLAGS CROSS_COMPILE AS LD CC export CPP AR NM STRIP OBJCOPY OBJDUMP HOSTLDFLAGS HOST_LOADLIBES export MAKE AWK GENKSYMS INSTALLKERNEL PERL PYTHON UTS_MACHINE export HOSTCXX HOSTCXXFLAGS LDFLAGS_MODULE CHECK CHECKFLAGS

export KBUILD_CPPFLAGS NOSTDINC_FLAGS LINUXINCLUDE OBJCOPYFLAGS LDFLAGS export KBUILD_CFLAGS CFLAGS_KERNEL CFLAGS_MODULE export CFLAGS_KASAN CFLAGS_KASAN_NOSANITIZE CFLAGS_UBSAN export KBUILD_AFLAGS AFLAGS_KERNEL AFLAGS_MODULE export KBUILD_AFLAGS_MODULE KBUILD_CFLAGS_MODULE KBUILD_LDFLAGS_MODULE export KBUILD_AFLAGS_KERNEL KBUILD_CFLAGS_KERNEL export KBUILD_ARFLAGS

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

Files to ignore in find ... statements

export RCS_FIND_IGNORE := ( -name SCCS -o -name BitKeeper -o -name .svn -o
-name CVS -o -name .pc -o -name .hg -o -name .git -o -name meta )
-prune -o export RCS_TAR_IGNORE := --exclude SCCS --exclude BitKeeper --exclude .svn
--exclude CVS --exclude .pc --exclude .hg --exclude .git

===========================================================================

Rules shared between *config targets and build targets

Basic helpers built in scripts/basic/

PHONY += scripts_basic scripts_basic: $(Q)$(MAKE) $(build)=scripts/basic $(Q)rm -f .tmp_quiet_recordmcount

To avoid any implicit rule to kick in, define an empty command.

scripts/basic/%: scripts_basic ;

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)ln -fsn $(srctree) source $(Q)$(CONFIG_SHELL) $(srctree)/scripts/mkmakefile
$(srctree) $(objtree) $(VERSION) $(PATCHLEVEL) endif

ifeq ($(cc-name),clang) ifneq ($(CROSS_COMPILE),) CLANG_FLAGS += --target=$(notdir $(CROSS_COMPILE:%-=%)) GCC_TOOLCHAIN_DIR := $(dir $(shell which $(CROSS_COMPILE)elfedit)) CLANG_FLAGS += --prefix=$(GCC_TOOLCHAIN_DIR)$(notdir $(CROSS_COMPILE)) GCC_TOOLCHAIN := $(realpath $(GCC_TOOLCHAIN_DIR)/..) endif ifneq ($(GCC_TOOLCHAIN),) CLANG_FLAGS += --gcc-toolchain=$(GCC_TOOLCHAIN) endif CLANG_FLAGS += -no-integrated-as CLANG_FLAGS += -Werror=unknown-warning-option KBUILD_CFLAGS += $(CLANG_FLAGS) KBUILD_AFLAGS += $(CLANG_FLAGS) export CLANG_FLAGS endif

RETPOLINE_CFLAGS_GCC := -mindirect-branch=thunk-extern -mindirect-branch-register RETPOLINE_VDSO_CFLAGS_GCC := -mindirect-branch=thunk-inline -mindirect-branch-register RETPOLINE_CFLAGS_CLANG := -mretpoline-external-thunk RETPOLINE_VDSO_CFLAGS_CLANG := -mretpoline RETPOLINE_CFLAGS := $(call cc-option,$(RETPOLINE_CFLAGS_GCC),$(call cc-option,$(RETPOLINE_CFLAGS_CLANG))) RETPOLINE_VDSO_CFLAGS := $(call cc-option,$(RETPOLINE_VDSO_CFLAGS_GCC),$(call cc-option,$(RETPOLINE_VDSO_CFLAGS_CLANG))) export RETPOLINE_CFLAGS export RETPOLINE_VDSO_CFLAGS

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 arch/$(SRCARCH)/Makefile export KBUILD_DEFCONFIG KBUILD_KCONFIG

config: scripts_basic outputmakefile FORCE $(Q)$(MAKE) $(build)=scripts/kconfig $@

%config: scripts_basic outputmakefile FORCE $(Q)$(MAKE) $(build)=scripts/kconfig $@

else

===========================================================================

Build targets only - this includes vmlinux, arch specific targets, clean

targets and others. In general all targets except *config targets.

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

Decide whether to build built-in, modular, or both.

Normally, just do built-in.

KBUILD_MODULES := KBUILD_BUILTIN := 1

If we have only "make modules", don't compile built-in objects.

ifeq ($(MAKECMDGOALS),modules) KBUILD_BUILTIN := endif

If we have "make 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

ifeq ($(MAKECMDGOALS),) KBUILD_MODULES := 1 endif

export KBUILD_MODULES KBUILD_BUILTIN

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 include/config/tristate.conf
asm-generic gcc-plugins $(Q)$(MAKE) $(build)=$(@)

Objects we will link into vmlinux / subdirs we need to visit

init-y := init/ drivers-y := drivers/ sound/ firmware/ net-y := net/ libs-y := lib/ core-y := usr/ virt-y := virt/ endif # KBUILD_EXTMOD

ifeq ($(dot-config),1)

Read in config

-include include/config/auto.conf

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

To avoid any implicit rule to kick in, define an empty command

$(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/%.conf: $(KCONFIG_CONFIG) include/config/auto.conf.cmd $(Q)$(MAKE) -f $(srctree)/Makefile silentoldconfig else

external modules needs include/generated/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

include/config/auto.conf: $(Q)test -e include/generated/autoconf.h -a -e $@ || (
echo >&2;
echo >&2 " ERROR: Kernel configuration is invalid.";
echo >&2 " include/generated/autoconf.h or $@ are missing.";
echo >&2 " Run 'make oldconfig && make prepare' on kernel src to fix it.";
echo >&2 ;
/bin/false)

endif # KBUILD_EXTMOD

else

Dummy target needed, because used as prerequisite

include/config/auto.conf: ; endif # $(dot-config)

For the kernel to actually contain only the needed exported symbols,

we have to build modules as well to determine what those symbols are.

(this can be evaluated only once include/config/auto.conf has been included)

ifdef CONFIG_TRIM_UNUSED_KSYMS KBUILD_MODULES := 1 endif

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 to vmlinux, but the arch makefile usually adds further targets

all: vmlinux

KBUILD_CFLAGS += $(call cc-option,-fno-PIE) KBUILD_AFLAGS += $(call cc-option,-fno-PIE) CFLAGS_GCOV := -fprofile-arcs -ftest-coverage -fno-tree-loop-im $(call cc-disable-warning,maybe-uninitialized,) CFLAGS_KCOV := $(call cc-option,-fsanitize-coverage=trace-pc,) export CFLAGS_GCOV CFLAGS_KCOV

The arch Makefile can set ARCH_{CPP,A,C}FLAGS to override the default

values of the respective KBUILD_* variables

ARCH_CPPFLAGS := ARCH_AFLAGS := ARCH_CFLAGS := include arch/$(SRCARCH)/Makefile

KBUILD_CFLAGS += $(call cc-option,-fno-delete-null-pointer-checks,) KBUILD_CFLAGS += $(call cc-disable-warning,frame-address,) KBUILD_CFLAGS += $(call cc-disable-warning, format-truncation) KBUILD_CFLAGS += $(call cc-disable-warning, format-overflow) KBUILD_CFLAGS += $(call cc-disable-warning, int-in-bool-context) KBUILD_CFLAGS += $(call cc-disable-warning, address-of-packed-member) KBUILD_CFLAGS += $(call cc-disable-warning, attribute-alias)

ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE KBUILD_CFLAGS += -Os else KBUILD_CFLAGS += -O2 endif

Tell gcc to never replace conditional load with a non-conditional one

KBUILD_CFLAGS += $(call cc-option,--param=allow-store-data-races=0) KBUILD_CFLAGS += $(call cc-option,-fno-allow-store-data-races)

check for 'asm goto'

ifeq ($(shell $(CONFIG_SHELL) $(srctree)/scripts/gcc-goto.sh $(CC) $(KBUILD_CFLAGS)), y) KBUILD_CFLAGS += -DCC_HAVE_ASM_GOTO KBUILD_AFLAGS += -DCC_HAVE_ASM_GOTO endif

include scripts/Makefile.gcc-plugins

ifdef CONFIG_READABLE_ASM

Disable optimizations that make assembler listings hard to read.

reorder blocks reorders the control in the function

ipa clone creates specialized cloned functions

partial inlining inlines only parts of functions

KBUILD_CFLAGS += $(call cc-option,-fno-reorder-blocks,)
$(call cc-option,-fno-ipa-cp-clone,)
$(call cc-option,-fno-partial-inlining) endif

ifneq ($(CONFIG_FRAME_WARN),0) KBUILD_CFLAGS += $(call cc-option,-Wframe-larger-than=${CONFIG_FRAME_WARN}) endif

This selects the stack protector compiler flag. Testing it is delayed

until after .config has been reprocessed, in the prepare-compiler-check

target.

ifdef CONFIG_CC_STACKPROTECTOR_REGULAR stackp-flag := -fstack-protector stackp-name := REGULAR else ifdef CONFIG_CC_STACKPROTECTOR_STRONG stackp-flag := -fstack-protector-strong stackp-name := STRONG else

Force off for distro compilers that enable stack protector by default.

stackp-flag := $(call cc-option, -fno-stack-protector) endif endif

Find arch-specific stack protector compiler sanity-checking script.

ifdef CONFIG_CC_STACKPROTECTOR stackp-path := $(srctree)/scripts/gcc-$(SRCARCH)_$(BITS)-has-stack-protector.sh stackp-check := $(wildcard $(stackp-path)) endif KBUILD_CFLAGS += $(stackp-flag)

ifeq ($(cc-name),clang) KBUILD_CPPFLAGS += $(call cc-option,-Qunused-arguments,) KBUILD_CFLAGS += $(call cc-disable-warning, format-invalid-specifier) KBUILD_CFLAGS += $(call cc-disable-warning, gnu)

Quiet clang warning: comparison of unsigned expression < 0 is always false

KBUILD_CFLAGS += $(call cc-disable-warning, tautological-compare)

CLANG uses a _MergedGlobals as optimization, but this breaks modpost, as the

source of a reference will be _MergedGlobals and not on of the whitelisted names.

See modpost pattern 2

KBUILD_CFLAGS += $(call cc-option, -mno-global-merge,) KBUILD_CFLAGS += $(call cc-option, -fcatch-undefined-behavior) else

These warnings generated too much noise in a regular build.

Use make W=1 to enable them (see scripts/Makefile.extrawarn)

KBUILD_CFLAGS += $(call cc-disable-warning, unused-but-set-variable) endif

KBUILD_CFLAGS += $(call cc-disable-warning, unused-const-variable) ifdef CONFIG_FRAME_POINTER KBUILD_CFLAGS += -fno-omit-frame-pointer -fno-optimize-sibling-calls else

Some targets (ARM with Thumb2, for example), can't be built with frame

pointers. For those, we don't have FUNCTION_TRACER automatically

select FRAME_POINTER. However, FUNCTION_TRACER adds -pg, and this is

incompatible with -fomit-frame-pointer with current GCC, so we don't use

-fomit-frame-pointer with FUNCTION_TRACER.

ifndef CONFIG_FUNCTION_TRACER KBUILD_CFLAGS += -fomit-frame-pointer endif endif

KBUILD_CFLAGS += $(call cc-option, -fno-var-tracking-assignments)

ifdef CONFIG_DEBUG_INFO ifdef CONFIG_DEBUG_INFO_SPLIT KBUILD_CFLAGS += $(call cc-option, -gsplit-dwarf, -g) else KBUILD_CFLAGS += -g endif KBUILD_AFLAGS += -Wa,-gdwarf-2 endif ifdef CONFIG_DEBUG_INFO_DWARF4 KBUILD_CFLAGS += $(call cc-option, -gdwarf-4,) endif

ifdef CONFIG_DEBUG_INFO_REDUCED KBUILD_CFLAGS += $(call cc-option, -femit-struct-debug-baseonly)
$(call cc-option,-fno-var-tracking) endif

ifdef CONFIG_FUNCTION_TRACER ifndef CC_FLAGS_FTRACE CC_FLAGS_FTRACE := -pg endif export CC_FLAGS_FTRACE ifdef CONFIG_HAVE_FENTRY CC_USING_FENTRY := $(call cc-option, -mfentry -DCC_USING_FENTRY) endif KBUILD_CFLAGS += $(CC_FLAGS_FTRACE) $(CC_USING_FENTRY) KBUILD_AFLAGS += $(CC_USING_FENTRY) ifdef CONFIG_DYNAMIC_FTRACE ifdef CONFIG_HAVE_C_RECORDMCOUNT BUILD_C_RECORDMCOUNT := y export BUILD_C_RECORDMCOUNT endif endif endif

We trigger additional mismatches with less inlining

ifdef CONFIG_DEBUG_SECTION_MISMATCH KBUILD_CFLAGS += $(call cc-option, -fno-inline-functions-called-once) endif

ifdef CONFIG_LD_DEAD_CODE_DATA_ELIMINATION KBUILD_CFLAGS += $(call cc-option,-ffunction-sections,) KBUILD_CFLAGS += $(call cc-option,-fdata-sections,) endif

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)

warn about C99 declaration after statement

KBUILD_CFLAGS += $(call cc-option,-Wdeclaration-after-statement,)

disable pointer signed / unsigned warnings in gcc 4.0

KBUILD_CFLAGS += $(call cc-disable-warning, pointer-sign)

disable stringop warnings in gcc 8+

KBUILD_CFLAGS += $(call cc-disable-warning, stringop-truncation)

We'll want to enable this eventually, but it's not going away for 5.7 at least

KBUILD_CFLAGS += $(call cc-disable-warning, zero-length-bounds) KBUILD_CFLAGS += $(call cc-disable-warning, array-bounds) KBUILD_CFLAGS += $(call cc-disable-warning, stringop-overflow)

Another good warning that we'll want to enable eventually

KBUILD_CFLAGS += $(call cc-disable-warning, restrict)

Enabled with W=2, disabled by default as noisy

KBUILD_CFLAGS += $(call cc-disable-warning, maybe-uninitialized)

disable invalid "can't wrap" optimizations for signed / pointers

KBUILD_CFLAGS += $(call cc-option,-fno-strict-overflow)

clang sets -fmerge-all-constants by default as optimization, but this

is non-conforming behavior for C and in fact breaks the kernel, so we

need to disable it here generally.

KBUILD_CFLAGS += $(call cc-option,-fno-merge-all-constants)

for gcc -fno-merge-all-constants disables everything, but it is fine

to have actual conforming behavior enabled.

KBUILD_CFLAGS += $(call cc-option,-fmerge-constants)

Make sure -fstack-check isn't enabled (like gentoo apparently did)

KBUILD_CFLAGS += $(call cc-option,-fno-stack-check,)

conserve stack if available

KBUILD_CFLAGS += $(call cc-option,-fconserve-stack)

disallow errors like 'EXPORT_GPL(foo);' with missing header

KBUILD_CFLAGS += $(call cc-option,-Werror=implicit-int)

require functions to have arguments in prototypes, not empty 'int foo()'

KBUILD_CFLAGS += $(call cc-option,-Werror=strict-prototypes)

Prohibit date/time macros, which would make the build non-deterministic

KBUILD_CFLAGS += $(call cc-option,-Werror=date-time)

enforce correct pointer usage

KBUILD_CFLAGS += $(call cc-option,-Werror=incompatible-pointer-types)

Require designated initializers for all marked structures

KBUILD_CFLAGS += $(call cc-option,-Werror=designated-init)

change FILE to the relative path from the srctree

KBUILD_CFLAGS += $(call cc-option,-fmacro-prefix-map=$(srctree)/=)

ensure -fcf-protection is disabled when using retpoline as it is

incompatible with -mindirect-branch=thunk-extern

ifdef CONFIG_RETPOLINE KBUILD_CFLAGS += $(call cc-option,-fcf-protection=none) endif

use the deterministic mode of AR if available

KBUILD_ARFLAGS := $(call ar-option,D)

include scripts/Makefile.kasan include scripts/Makefile.extrawarn include scripts/Makefile.ubsan

Add any arch overrides and user supplied CPPFLAGS, AFLAGS and CFLAGS as the

last assignments

KBUILD_CPPFLAGS += $(ARCH_CPPFLAGS) $(KCPPFLAGS) KBUILD_AFLAGS += $(ARCH_AFLAGS) $(KAFLAGS) KBUILD_CFLAGS += $(ARCH_CFLAGS) $(KCFLAGS)

Use --build-id when available.

LDFLAGS_BUILD_ID := $(patsubst -Wl$(comma)%,%,
$(call cc-ldoption, -Wl$(comma)--build-id,)) KBUILD_LDFLAGS_MODULE += $(LDFLAGS_BUILD_ID) LDFLAGS_vmlinux += $(LDFLAGS_BUILD_ID)

ifdef CONFIG_LD_DEAD_CODE_DATA_ELIMINATION LDFLAGS_vmlinux += $(call ld-option, --gc-sections,) endif

ifeq ($(CONFIG_STRIP_ASM_SYMS),y) LDFLAGS_vmlinux += $(call ld-option, -X,) endif

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

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_DTBS_PATH specifies a prefix for relocations required by build roots.

Like INSTALL_MOD_PATH, it isn't defined in the Makefile, but can be passed as

an argument if needed. Otherwise it defaults to the kernel install path

export INSTALL_DTBS_PATH ?= $(INSTALL_PATH)/dtbs/$(KERNELRELEASE)

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

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 value will be used as the options to the strip command.

ifdef INSTALL_MOD_STRIP ifeq ($(INSTALL_MOD_STRIP),1) mod_strip_cmd = $(STRIP) --strip-debug else mod_strip_cmd = $(STRIP) $(INSTALL_MOD_STRIP) endif # INSTALL_MOD_STRIP=1 else mod_strip_cmd = true endif # INSTALL_MOD_STRIP export mod_strip_cmd

CONFIG_MODULE_COMPRESS, if defined, will cause module to be compressed

after they are installed in agreement with CONFIG_MODULE_COMPRESS_GZIP

or CONFIG_MODULE_COMPRESS_XZ.

mod_compress_cmd = true ifdef CONFIG_MODULE_COMPRESS ifdef CONFIG_MODULE_COMPRESS_GZIP mod_compress_cmd = gzip -n -f endif # CONFIG_MODULE_COMPRESS_GZIP ifdef CONFIG_MODULE_COMPRESS_XZ mod_compress_cmd = xz -f endif # CONFIG_MODULE_COMPRESS_XZ endif # CONFIG_MODULE_COMPRESS export mod_compress_cmd

Select initial ramdisk compression format, default is gzip(1).

This shall be used by the dracut(8) tool while creating an initramfs image.

INITRD_COMPRESS-y := gzip INITRD_COMPRESS-$(CONFIG_RD_BZIP2) := bzip2 INITRD_COMPRESS-$(CONFIG_RD_LZMA) := lzma INITRD_COMPRESS-$(CONFIG_RD_XZ) := xz INITRD_COMPRESS-$(CONFIG_RD_LZO) := lzo INITRD_COMPRESS-$(CONFIG_RD_LZ4) := lz4

do not export INITRD_COMPRESS, since we didn't actually

choose a sane default compression above.

export INITRD_COMPRESS := $(INITRD_COMPRESS-y)

ifdef CONFIG_MODULE_SIG_ALL $(eval $(call config_filename,MODULE_SIG_KEY))

mod_sign_cmd = scripts/sign-file $(CONFIG_MODULE_SIG_HASH) $(MODULE_SIG_KEY_SRCPREFIX)$(CONFIG_MODULE_SIG_KEY) certs/signing_key.x509 else mod_sign_cmd = true endif export mod_sign_cmd

HOST_LIBELF_LIBS = $(shell pkg-config libelf --libs 2>/dev/null || echo -lelf)

ifdef CONFIG_STACK_VALIDATION has_libelf := $(call try-run,
echo "int main() {}" | $(HOSTCC) -xc -o /dev/null $(HOST_LIBELF_LIBS) -,1,0) ifeq ($(has_libelf),1) objtool_target := tools/objtool FORCE else SKIP_STACK_VALIDATION := 1 export SKIP_STACK_VALIDATION endif endif

PHONY += prepare0

ifeq ($(KBUILD_EXTMOD),) core-y += kernel/ certs/ mm/ fs/ ipc/ security/ crypto/ block/

vmlinux-dirs := $(patsubst %/,%,$(filter %/, $(init-y) $(init-m)
$(core-y) $(core-m) $(drivers-y) $(drivers-m)
$(net-y) $(net-m) $(libs-y) $(libs-m) $(virt-y)))

vmlinux-alldirs := $(sort $(vmlinux-dirs) $(patsubst %/,%,$(filter %/,
$(init-) $(core-) $(drivers-) $(net-) $(libs-) $(virt-))))

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 := $(filter-out %.a, $(patsubst %/, %/built-in.o, $(libs-y))) virt-y := $(patsubst %/, %/built-in.o, $(virt-y))

Externally visible symbols (used by link-vmlinux.sh)

export KBUILD_VMLINUX_INIT := $(head-y) $(init-y) export KBUILD_VMLINUX_MAIN := $(core-y) $(libs-y2) $(drivers-y) $(net-y) $(virt-y) export KBUILD_VMLINUX_LIBS := $(libs-y1) export KBUILD_LDS := arch/$(SRCARCH)/kernel/vmlinux.lds export LDFLAGS_vmlinux

used by scripts/package/Makefile

export KBUILD_ALLDIRS := $(sort $(filter-out arch/%,$(vmlinux-alldirs)) arch Documentation include samples scripts tools)

vmlinux-deps := $(KBUILD_LDS) $(KBUILD_VMLINUX_INIT) $(KBUILD_VMLINUX_MAIN) $(KBUILD_VMLINUX_LIBS)

Include targets which we want to execute sequentially if the rest of the

kernel build went well. If CONFIG_TRIM_UNUSED_KSYMS is set, this might be

evaluated more than once.

PHONY += vmlinux_prereq vmlinux_prereq: $(vmlinux-deps) FORCE ifdef CONFIG_HEADERS_CHECK $(Q)$(MAKE) -f $(srctree)/Makefile headers_check endif ifdef CONFIG_GDB_SCRIPTS $(Q)ln -fsn $(abspath $(srctree)/scripts/gdb/vmlinux-gdb.py) endif ifdef CONFIG_TRIM_UNUSED_KSYMS $(Q)$(CONFIG_SHELL) $(srctree)/scripts/adjust_autoksyms.sh
"$(MAKE) -f $(srctree)/Makefile vmlinux" endif

standalone target for easier testing

include/generated/autoksyms.h: FORCE $(Q)$(CONFIG_SHELL) $(srctree)/scripts/adjust_autoksyms.sh true

ARCH_POSTLINK := $(wildcard $(srctree)/arch/$(SRCARCH)/Makefile.postlink)

Final link of vmlinux with optional arch pass after final link

cmd_link-vmlinux =
$(CONFIG_SHELL) $< $(LD) $(LDFLAGS) $(LDFLAGS_vmlinux) ;
$(if $(ARCH_POSTLINK), $(MAKE) -f $(ARCH_POSTLINK) $@, true)

vmlinux: scripts/link-vmlinux.sh vmlinux_prereq $(vmlinux-deps) FORCE +$(call if_changed,link-vmlinux)

Build samples along the rest of the kernel

ifdef CONFIG_SAMPLES vmlinux-dirs += samples endif

The actual objects are generated when descending,

make sure no implicit rule kicks in

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

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)=$@

define filechk_kernel.release echo "$(KERNELVERSION)$$($(CONFIG_SHELL) $(srctree)/scripts/setlocalversion $(srctree))" endef

Store (new) KERNELRELEASE string in include/config/kernel.release

include/config/kernel.release: include/config/auto.conf FORCE $(call filechk,kernel.release)

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.

PHONY += prepare archprepare prepare1 prepare2 prepare3

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)

prepare3: include/config/kernel.release ifneq ($(KBUILD_SRC),) @$(kecho) ' Using $(srctree) as source for kernel' $(Q)if [ -f $(srctree)/.config -o -d $(srctree)/include/config ]; then
echo >&2 " $(srctree) is not clean, please run 'make mrproper'";
echo >&2 " in the '$(srctree)' directory.";
/bin/false;
fi; endif

prepare2 creates a makefile if using a separate output directory.

From this point forward, .config has been reprocessed, so any rules

that need to depend on updated CONFIG_* values can be checked here.

prepare2: prepare3 prepare-compiler-check outputmakefile asm-generic

prepare1: prepare2 $(version_h) include/generated/utsrelease.h
include/config/auto.conf $(cmd_crmodverdir)

archprepare: archheaders archscripts prepare1 scripts_basic

prepare0: archprepare gcc-plugins $(Q)$(MAKE) $(build)=.

All the preparing..

prepare: prepare0 prepare-objtool

Support for using generic headers in asm-generic

PHONY += asm-generic uapi-asm-generic asm-generic: uapi-asm-generic $(Q)$(MAKE) -f $(srctree)/scripts/Makefile.asm-generic
src=asm obj=arch/$(SRCARCH)/include/generated/asm uapi-asm-generic: $(Q)$(MAKE) -f $(srctree)/scripts/Makefile.asm-generic
src=uapi/asm obj=arch/$(SRCARCH)/include/generated/uapi/asm

PHONY += prepare-objtool prepare-objtool: $(objtool_target) ifeq ($(SKIP_STACK_VALIDATION),1) ifdef CONFIG_UNWINDER_ORC @echo "error: Cannot generate ORC metadata for CONFIG_UNWINDER_ORC=y, please install libelf-dev, libelf-devel or elfutils-libelf-devel" >&2 @false else @echo "warning: Cannot use CONFIG_STACK_VALIDATION=y, please install libelf-dev, libelf-devel or elfutils-libelf-devel" >&2 endif endif

Check for CONFIG flags that require compiler support. Abort the build

after .config has been processed, but before the kernel build starts.

For security-sensitive CONFIG options, we don't want to fallback and/or

silently change which compiler flags will be used, since that leads to

producing kernels with different security feature characteristics

depending on the compiler used. (For example, "But I selected

CC_STACKPROTECTOR_STRONG! Why did it build with _REGULAR?!")

PHONY += prepare-compiler-check prepare-compiler-check: FORCE

Make sure compiler supports requested stack protector flag.

ifdef stackp-name ifeq ($(call cc-option, $(stackp-flag)),) @echo Cannot use CONFIG_CC_STACKPROTECTOR_$(stackp-name):
$(stackp-flag) not supported by compiler >&2 && exit 1 endif endif

Make sure compiler does not have buggy stack-protector support.

ifdef stackp-check ifneq ($(shell $(CONFIG_SHELL) $(stackp-check) $(CC) $(KBUILD_CPPFLAGS) $(biarch)),y) @echo Cannot use CONFIG_CC_STACKPROTECTOR_$(stackp-name):
$(stackp-flag) available but compiler is broken >&2 && exit 1 endif endif @:

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

define filechk_version.h (echo #define LINUX_VERSION_CODE $(shell
expr $(VERSION) * 65536 + 0$(PATCHLEVEL) * 256 + 0$(SUBLEVEL));
echo '#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))';) endef

$(version_h): $(srctree)/Makefile FORCE $(call filechk,version.h) $(Q)rm -f $(old_version_h)

include/generated/utsrelease.h: include/config/kernel.release FORCE $(call filechk,utsrelease.h)

PHONY += headerdep headerdep: $(Q)find $(srctree)/include/ -name '*.h' | xargs --max-args 1
$(srctree)/scripts/headerdep.pl -I$(srctree)/include

---------------------------------------------------------------------------

Kernel headers

#Default location for installed headers export INSTALL_HDR_PATH = $(objtree)/usr

If we do an all arch process set dst to include/arch-$(hdr-arch)

hdr-dst = $(if $(KBUILD_HEADERS), dst=include/arch-$(hdr-arch), dst=include)

PHONY += archheaders archheaders:

PHONY += archscripts archscripts:

PHONY += __headers __headers: $(version_h) scripts_basic uapi-asm-generic archheaders archscripts $(Q)$(MAKE) $(build)=scripts build_unifdef

PHONY += headers_install_all headers_install_all: $(Q)$(CONFIG_SHELL) $(srctree)/scripts/headers.sh install

PHONY += headers_install headers_install: __headers $(if $(wildcard $(srctree)/arch/$(hdr-arch)/include/uapi/asm/Kbuild),,
$(error Headers not exportable for the $(SRCARCH) architecture)) $(Q)$(MAKE) $(hdr-inst)=include/uapi dst=include $(Q)$(MAKE) $(hdr-inst)=arch/$(hdr-arch)/include/uapi $(hdr-dst)

PHONY += headers_check_all headers_check_all: headers_install_all $(Q)$(CONFIG_SHELL) $(srctree)/scripts/headers.sh check

PHONY += headers_check headers_check: headers_install $(Q)$(MAKE) $(hdr-inst)=include/uapi dst=include HDRCHECK=1 $(Q)$(MAKE) $(hdr-inst)=arch/$(hdr-arch)/include/uapi $(hdr-dst) HDRCHECK=1

---------------------------------------------------------------------------

Kernel selftest

PHONY += kselftest kselftest: $(Q)$(MAKE) -C $(srctree)/tools/testing/selftests run_tests

PHONY += kselftest-clean kselftest-clean: $(Q)$(MAKE) -C $(srctree)/tools/testing/selftests clean

PHONY += kselftest-merge kselftest-merge: $(if $(wildcard $(objtree)/.config),, $(error No .config exists, config your kernel first!)) $(Q)$(CONFIG_SHELL) $(srctree)/scripts/kconfig/merge_config.sh
-m $(objtree)/.config
$(srctree)/tools/testing/selftests/*/config +$(Q)$(MAKE) -f $(srctree)/Makefile olddefconfig

---------------------------------------------------------------------------

Modules

ifdef CONFIG_MODULES

By default, build modules as well

all: modules

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.

ifdef CONFIG_MODVERSIONS KBUILD_BUILTIN := 1 endif

Build modules

A module can be listed more than once in obj-m resulting in

duplicate lines in modules.order files. Those are removed

using awk while concatenating to the final file.

PHONY += modules modules: $(vmlinux-dirs) $(if $(KBUILD_BUILTIN),vmlinux) modules.builtin $(Q)$(AWK) '!x[$$0]++' $(vmlinux-dirs:%=$(objtree)/%/modules.order) > $(objtree)/modules.order @$(kecho) ' Building modules, stage 2.'; $(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modpost

modules.builtin: $(vmlinux-dirs:%=%/modules.builtin) $(Q)$(AWK) '!x[$$0]++' $^ > $(objtree)/modules.builtin

%/modules.builtin: include/config/auto.conf $(Q)$(MAKE) $(modbuiltin)=$*

Target to prepare building external modules

PHONY += modules_prepare modules_prepare: prepare scripts

Target to install modules

PHONY += modules_install modules_install: modinst _modinst_post

PHONY += modinst modinst: @rm -rf $(MODLIB)/kernel @rm -f $(MODLIB)/source @mkdir -p $(MODLIB)/kernel @ln -s $(abspath $(srctree)) $(MODLIB)/source @if [ ! $(objtree) -ef $(MODLIB)/build ]; then
rm -f $(MODLIB)/build ;
ln -s $(CURDIR) $(MODLIB)/build ;
fi @cp -f $(objtree)/modules.order $(MODLIB)/ @cp -f $(objtree)/modules.builtin $(MODLIB)/ $(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modinst

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.

PHONY += _modinst_post _modinst_post: modinst $(call cmd,depmod)

ifeq ($(CONFIG_MODULE_SIG), y) PHONY += modules_sign modules_sign: $(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modsign endif

else # CONFIG_MODULES

Modules not configured

---------------------------------------------------------------------------

PHONY += modules modules_install modules modules_install: @echo >&2 @echo >&2 "The present kernel configuration has modules disabled." @echo >&2 "Type 'make config' and enable loadable module support." @echo >&2 "Then build a kernel with module support enabled." @echo >&2 @exit 1

endif # 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)

Directories & files removed with 'make mrproper'

MRPROPER_DIRS += include/config usr/include include/generated
arch//include/generated .tmp_objdiff MRPROPER_FILES += .config .config.old .version .old_version
Module.symvers tags TAGS cscope GPATH GTAGS GRTAGS GSYMS
signing_key.pem signing_key.priv signing_key.x509
x509.genkey extra_certificates signing_key.x509.keyid
signing_key.x509.signer vmlinux-gdb.py

clean - Delete most, but leave enough to build external modules

clean: rm-dirs := $(CLEAN_DIRS) clean: rm-files := $(CLEAN_FILES) clean-dirs := $(addprefix clean, . $(vmlinux-alldirs) Documentation samples)

PHONY += $(clean-dirs) clean archclean vmlinuxclean $(clean-dirs): $(Q)$(MAKE) $(clean)=$(patsubst clean%,%,$@)

vmlinuxclean: $(Q)$(CONFIG_SHELL) $(srctree)/scripts/link-vmlinux.sh clean $(Q)$(if $(ARCH_POSTLINK), $(MAKE) -f $(ARCH_POSTLINK) clean)

clean: archclean vmlinuxclean

mrproper - Delete all generated files, including .config

mrproper: rm-dirs := $(wildcard $(MRPROPER_DIRS)) mrproper: rm-files := $(wildcard $(MRPROPER_FILES)) mrproper-dirs := $(addprefix mrproper,scripts)

PHONY += $(mrproper-dirs) mrproper archmrproper $(mrproper-dirs): $(Q)$(MAKE) $(clean)=$(patsubst mrproper%,%,$@)

mrproper: clean archmrproper $(mrproper-dirs) $(call cmd,rmdirs) $(call cmd,rmfiles)

distclean

PHONY += distclean

distclean: mrproper @find $(srctree) $(RCS_FIND_IGNORE)
( -name '.orig' -o -name '.rej' -o -name '~'
-o -name '.bak' -o -name '##' -o -name '%'
-o -name 'core' )
-type f -print | xargs rm -f

Packaging of the kernel to various formats

---------------------------------------------------------------------------

rpm target kept for backward compatibility

package-dir := scripts/package

%src-pkg: FORCE $(Q)$(MAKE) $(build)=$(package-dir) $@ %pkg: include/config/kernel.release FORCE $(Q)$(MAKE) $(build)=$(package-dir) $@ rpm: include/config/kernel.release FORCE $(Q)$(MAKE) $(build)=$(package-dir) $@

Brief documentation of the typical targets used

---------------------------------------------------------------------------

boards := $(wildcard $(srctree)/arch/$(SRCARCH)/configs/_defconfig) boards := $(sort $(notdir $(boards))) board-dirs := $(dir $(wildcard $(srctree)/arch/$(SRCARCH)/configs//*_defconfig)) board-dirs := $(sort $(notdir $(board-dirs:/=)))

PHONY += help 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.ll - Build the LLVM assembly file' @echo ' (requires compiler support for LLVM assembly generation)' @echo ' dir/file.lst - Build specified mixed source/assembly target only' @echo ' (requires a recent binutils and recent build (System.map))' @echo ' dir/file.ko - Build module including final link' @echo ' modules_prepare - Set up for building external modules' @echo ' tags/TAGS - Generate tags file for editors' @echo ' cscope - Generate cscope index' @echo ' gtags - Generate GNU GLOBAL index' @echo ' kernelrelease - Output the release version string (use with make -s)' @echo ' kernelversion - Output the version stored in Makefile (use with make -s)' @echo ' image_name - Output the image name (use with make -s)' @echo ' headers_install - Install sanitised kernel headers to INSTALL_HDR_PATH';
echo ' (default: $(INSTALL_HDR_PATH))';
echo '' @echo 'Static analysers:' @echo ' checkstack - Generate a list of stack hogs' @echo ' namespacecheck - Name space analysis on compiled kernel' @echo ' versioncheck - Sanity check on version.h usage' @echo ' includecheck - Check for duplicate included header files' @echo ' export_report - List the usages of all exported symbols' @echo ' headers_check - Sanity check on exported headers' @echo ' headerdep - Detect inclusion cycles in headers' @$(MAKE) -f $(srctree)/scripts/Makefile.help checker-help @echo '' @echo 'Kernel selftest:' @echo ' kselftest - Build and run kernel selftest (run as root)' @echo ' Build, install, and boot kernel before' @echo ' running kselftest on it' @echo ' kselftest-clean - Remove all generated kselftest files' @echo ' kselftest-merge - Merge all the config dependencies of kselftest to existing' @echo ' .config.' @echo '' @echo 'Userspace tools targets:' @echo ' use "make tools/help"' @echo ' or "cd tools; make help"' @echo '' @echo 'Kernel packaging:' @$(MAKE) $(build)=$(package-dir) help @echo '' @echo 'Documentation targets:' @$(MAKE) -f $(srctree)/Documentation/Makefile dochelp @echo '' @echo 'Architecture specific targets ($(SRCARCH)):' @$(if $(archhelp),$(archhelp),
echo ' No architecture specific help defined for $(SRCARCH)') @echo '' @$(if $(boards),
$(foreach b, $(boards),
printf " %-24s - Build for %s\n" $(b) $(subst _defconfig,,$(b));)
echo '') @$(if $(board-dirs),
$(foreach b, $(board-dirs),
printf " %-16s - Show %s-specific targets\n" help-$(b) $(b);)
printf " %-16s - Show all of the above\n" help-boards;
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 re-compiled c source with $$CHECK (sparse by default)'
@echo  '  make C=2   [targets] Force check of all c source with $$CHECK'
@echo  '  make RECORDMCOUNT_WARN=1 [targets] Warn about ignored mcount sections'
@echo  '  make W=n   [targets] Enable extra gcc checks, n=1,2,3 where'
@echo  '		1: warnings which may be relevant and do not occur too often'
@echo  '		2: warnings which occur quite often but may still be relevant'
@echo  '		3: more obscure warnings, can most likely be ignored'
@echo  '		Multiple levels can be combined with W=12 or W=123'
@echo  ''
@echo  'Execute "make" or "make all" to build all targets marked with [*] '
@echo  'For further info see the ./README file'

help-board-dirs := $(addprefix help-,$(board-dirs))

help-boards: $(help-board-dirs)

boards-per-dir = $(sort $(notdir $(wildcard $(srctree)/arch/$(SRCARCH)/configs/$/_defconfig)))

$(help-board-dirs): help-%: @echo 'Architecture specific targets ($(SRCARCH) $):' @$(if $(boards-per-dir),
$(foreach b, $(boards-per-dir),
printf " %-24s - Build for %s\n" $/$(b) $(subst _defconfig,,$(b));)
echo '')

Documentation targets

---------------------------------------------------------------------------

DOC_TARGETS := xmldocs latexdocs pdfdocs htmldocs epubdocs cleandocs linkcheckdocs PHONY += $(DOC_TARGETS) $(DOC_TARGETS): scripts_basic FORCE $(Q)$(MAKE) $(build)=Documentation $@

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 += $(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 )

module-dirs := $(addprefix module,$(KBUILD_EXTMOD)) PHONY += $(module-dirs) modules $(module-dirs): prepare $(objtree)/Module.symvers $(Q)$(MAKE) $(build)=$(patsubst module%,%,$@)

modules: $(module-dirs) @$(kecho) ' Building modules, stage 2.'; $(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modpost

PHONY += modules_install 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

PHONY += _emodinst_post _emodinst_post: emodinst $(call cmd,depmod)

clean-dirs := $(addprefix clean,$(KBUILD_EXTMOD))

PHONY += $(clean-dirs) clean $(clean-dirs): $(Q)$(MAKE) $(clean)=$(patsubst clean%,%,$@)

clean: rm-dirs := $(MODVERDIR) clean: rm-files := $(KBUILD_EXTMOD)/Module.symvers

PHONY += help 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 ''

Dummies...

PHONY += prepare scripts prepare: $(cmd_crmodverdir) scripts: ; endif # KBUILD_EXTMOD

clean: $(clean-dirs) $(call cmd,rmdirs) $(call cmd,rmfiles) @find $(if $(KBUILD_EXTMOD), $(KBUILD_EXTMOD), .) $(RCS_FIND_IGNORE)
( -name '.[oas]' -o -name '.ko' -o -name '..cmd'
-o -name '.ko.'
-o -name '.dwo'
-o -name '.su'
-o -name '..d' -o -name '..tmp' -o -name '.mod.c'
-o -name '.symtypes' -o -name 'modules.order'
-o -name modules.builtin -o -name '.tmp_.o.'
-o -name '.c.[012].'
-o -name '.ll'
-o -name '.gcno' ) -type f -print | xargs rm -f

Generate tags for editors

---------------------------------------------------------------------------

quiet_cmd_tags = GEN $@ cmd_tags = $(CONFIG_SHELL) $(srctree)/scripts/tags.sh $@

tags TAGS cscope gtags: FORCE $(call cmd,tags)

Scripts to check various things for consistency

---------------------------------------------------------------------------

PHONY += includecheck versioncheck coccicheck namespacecheck export_report

includecheck: find $(srctree)/* $(RCS_FIND_IGNORE)
-name '*.[hcS]' -type f -print | sort
| xargs $(PERL) -w $(srctree)/scripts/checkincludes.pl

versioncheck: find $(srctree)/* $(RCS_FIND_IGNORE)
-name '*.[hcS]' -type f -print | sort
| xargs $(PERL) -w $(srctree)/scripts/checkversion.pl

coccicheck: $(Q)$(CONFIG_SHELL) $(srctree)/scripts/$@

namespacecheck: $(PERL) $(srctree)/scripts/namespace.pl

export_report: $(PERL) $(srctree)/scripts/export_report.pl

endif #ifeq ($(config-targets),1) endif #ifeq ($(mixed-targets),1)

PHONY += checkstack kernelrelease kernelversion image_name

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)

kernelrelease: @echo "$(KERNELVERSION)$$($(CONFIG_SHELL) $(srctree)/scripts/setlocalversion $(srctree))"

kernelversion: @echo $(KERNELVERSION)

image_name: @echo $(KBUILD_IMAGE)

Clear a bunch of variables before executing the submake

tools/: FORCE $(Q)mkdir -p $(objtree)/tools $(Q)$(MAKE) LDFLAGS= MAKEFLAGS="$(tools_silent) $(filter --j% -j,$(MAKEFLAGS))" O=$(abspath $(objtree)) subdir=tools -C $(src)/tools/

tools/%: FORCE $(Q)mkdir -p $(objtree)/tools $(Q)$(MAKE) LDFLAGS= MAKEFLAGS="$(tools_silent) $(filter --j% -j,$(MAKEFLAGS))" O=$(abspath $(objtree)) subdir=tools -C $(src)/tools/ $*

Single targets

---------------------------------------------------------------------------

Single targets are compatible with:

- build with 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

%.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 $@) %.ll: %.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)

Make sure the latest headers are built for Documentation

Documentation/ samples/: headers_install %/: 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

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_rmfiles = $(if $(wildcard $(rm-files)),CLEAN $(wildcard $(rm-files))) cmd_rmfiles = rm -f $(rm-files)

Run depmod only if we have System.map and depmod is executable

quiet_cmd_depmod = DEPMOD $(KERNELRELEASE) cmd_depmod = $(CONFIG_SHELL) $(srctree)/scripts/depmod.sh $(DEPMOD)
$(KERNELRELEASE) "$(patsubst y,_,$(CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX))"

Create temporary dir for module support files

clean it up only when building all modules

cmd_crmodverdir = $(Q)mkdir -p $(MODVERDIR)
$(if $(KBUILD_MODULES),; rm -f $(MODVERDIR)/*)

read all saved command lines

targets := $(wildcard $(sort $(targets))) cmd_files := $(wildcard .*.cmd $(foreach f,$(targets),$(dir $(f)).$(notdir $(f)).cmd))

ifneq ($(cmd_files),) $(cmd_files): ; # Do not try to update included dependency files include $(cmd_files) endif

endif # skip-makefile

PHONY += FORCE FORCE:

Declare the contents of the .PHONY variable as phony. We keep that

information in a variable so we can use it in if_changed and friends.

.PHONY: $(PHONY)