VERSION = 3

PATCHLEVEL = 1

SUBLEVEL = 0

EXTRAVERSION = -rc5

NAME = "Divemaster Edition"

# *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 avoids hard-to-debug behaviour);

# o print "Entering directory ...";

MAKEFLAGS += -rR --no-print-directory

# Avoid funny character set dependencies

unexport LC_ALL

LC_COLLATE=C

LC_NUMERIC=C

export LC_COLLATE LC_NUMERIC

# 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

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

KBUILD_VERBOSE = $(V)

endif

ifndef KBUILD_VERBOSE

KBUILD_VERBOSE = 0

endif

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

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

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

# 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

ifeq ("$(origin W)", "command line")

export KBUILD_ENABLE_EXTRA_GCC_CHECKS := $(W)

endif

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

PHONY := _all

_all:

# Cancel implicit rules on top Makefile

$(CURDIR)/Makefile Makefile: ;

ifneq ($(KBUILD_OUTPUT),)

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

$(if $(KBUILD_OUTPUT),, \

$(error output directory "$(saved-output)" does not exist))

PHONY += $(MAKECMDGOALS) sub-make

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

$(Q)@:

sub-make: FORCE

$(if $(KBUILD_VERBOSE:1=),@)$(MAKE) -C $(KBUILD_OUTPUT) \

KBUILD_SRC=$(CURDIR) \

KBUILD_EXTMOD="$(KBUILD_EXTMOD)" -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),)

# 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

srctree := $(if $(KBUILD_SRC),$(KBUILD_SRC),$(CURDIR))

objtree := $(CURDIR)

src := $(srctree)

obj := $(objtree)

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

export srctree objtree VPATH

# 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/ \

-e s/sh[234].*/sh/ )

# 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

export KBUILD_BUILDHOST := $(SUBARCH)

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)

ifeq ($(ARCH),m68knommu)

hdr-arch := m68k

endif

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)

HOSTCC = gcc

HOSTCXX = g++

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

HOSTCXXFLAGS = -O2

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

# 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

# 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

ifeq ($(MAKECMDGOALS),)

KBUILD_MODULES := 1

endif

export KBUILD_MODULES KBUILD_BUILTIN

export KBUILD_CHECKSRC KBUILD_SRC KBUILD_EXTMOD

# 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

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

# commands

ifneq ($(findstring s,$(MAKEFLAGS)),)

quiet=silent_

endif

export quiet Q KBUILD_VERBOSE

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

MAKEFLAGS += --include-dir=$(srctree)

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

$(srctree)/scripts/Kbuild.include: ;

include $(srctree)/scripts/Kbuild.include

# 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

KALLSYMS = scripts/kallsyms

PERL = perl

CHECK = sparse

CHECKFLAGS := -D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ \

-Wbitwise -Wno-return-void $(CF)

CFLAGS_MODULE =

AFLAGS_MODULE =

LDFLAGS_MODULE =

CFLAGS_KERNEL =

AFLAGS_KERNEL =

CFLAGS_GCOV = -fprofile-arcs -ftest-coverage

# Use LINUXINCLUDE when you must reference the include/ directory.

# Needed to be compatible with the O= option

LINUXINCLUDE := -I$(srctree)/arch/$(hdr-arch)/include \

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

$(if $(KBUILD_SRC), -I$(srctree)/include) \

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

KBUILD_CPPFLAGS := -D__KERNEL__

KBUILD_CFLAGS := -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs \

-fno-strict-aliasing -fno-common \

-Werror-implicit-function-declaration \

-Wno-format-security \

-fno-delete-null-pointer-checks

KBUILD_AFLAGS_KERNEL :=

KBUILD_CFLAGS_KERNEL :=

KBUILD_AFLAGS := -D__ASSEMBLY__

KBUILD_AFLAGS_MODULE := -DMODULE

KBUILD_CFLAGS_MODULE := -DMODULE

KBUILD_LDFLAGS_MODULE := -T $(srctree)/scripts/module-common.lds

# 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

export ARCH SRCARCH CONFIG_SHELL HOSTCC HOSTCFLAGS CROSS_COMPILE AS LD CC

export CPP AR NM STRIP OBJCOPY OBJDUMP

export MAKE AWK GENKSYMS INSTALLKERNEL PERL UTS_MACHINE

export HOSTCXX HOSTCXXFLAGS LDFLAGS_MODULE CHECK CHECKFLAGS

export KBUILD_CPPFLAGS NOSTDINC_FLAGS LINUXINCLUDE OBJCOPYFLAGS LDFLAGS

export KBUILD_CFLAGS CFLAGS_KERNEL CFLAGS_MODULE CFLAGS_GCOV

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

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

# ===========================================================================

# Rules shared between *config targets and build targets

# Basic helpers built in scripts/

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

# Support for using generic headers in asm-generic

PHONY += asm-generic

asm-generic:

$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.asm-generic \

obj=arch/$(SRCARCH)/include/generated/asm

# 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 gtags TAGS tags help %docs check% coccicheck \

include/linux/version.h headers_% \

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 ($(filter-out config %config,$(MAKECMDGOALS)),)

mixed-targets := 1

endif

endif

endif

ifeq ($(mixed-targets),1)

# ===========================================================================

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

# Handle them one by one.

%:: FORCE

$(Q)$(MAKE) -C $(srctree) KBUILD_SRC= $@

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/$(SRCARCH)/Makefile

export KBUILD_DEFCONFIG KBUILD_KCONFIG

config: scripts_basic outputmakefile FORCE

$(Q)mkdir -p include/linux include/config

$(Q)$(MAKE) $(build)=scripts/kconfig $@

%config: scripts_basic outputmakefile FORCE

$(Q)mkdir -p include/linux include/config

$(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.

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

$(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/

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; \

echo " ERROR: Kernel configuration is invalid."; \

echo " include/generated/autoconf.h or $@ are missing.";\

echo " Run 'make oldconfig && make prepare' on kernel src to fix it."; \

echo; \

/bin/false)

endif # KBUILD_EXTMOD

else

# Dummy target needed, because used as prerequisite

include/config/auto.conf: ;

endif # $(dot-config)

# 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

ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE

KBUILD_CFLAGS += -Os

else

KBUILD_CFLAGS += -O2

endif

include $(srctree)/arch/$(SRCARCH)/Makefile

ifneq ($(CONFIG_FRAME_WARN),0)

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

endif

# Force gcc to behave correct even for buggy distributions

ifndef CONFIG_CC_STACKPROTECTOR

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

endif

# This warning generated too much noise in a regular build.

# Use make W=1 to enable this warning (see scripts/Makefile.build)

KBUILD_CFLAGS += $(call cc-disable-warning, unused-but-set-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

ifdef CONFIG_DEBUG_INFO

KBUILD_CFLAGS += -g

KBUILD_AFLAGS += -gdwarf-2

endif

ifdef CONFIG_DEBUG_INFO_REDUCED

KBUILD_CFLAGS += $(call cc-option, -femit-struct-debug-baseonly)

endif

ifdef CONFIG_FUNCTION_TRACER

KBUILD_CFLAGS += -pg

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

# 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 invalid "can't wrap" optimizations for signed / pointers

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

# conserve stack if available

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

# use the deterministic mode of AR if available

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

# check for 'asm goto'

ifeq ($(shell $(CONFIG_SHELL) $(srctree)/scripts/gcc-goto.sh $(CC)), y)

KBUILD_CFLAGS += -DCC_HAVE_ASM_GOTO

endif

# Add user supplied CPPFLAGS, AFLAGS and CFLAGS as the last assignments

# But warn user when we do so

warn-assign = \

$(warning "WARNING: Appending $$K$(1) ($(K$(1))) from $(origin K$(1)) to kernel $$$(1)")

ifneq ($(KCPPFLAGS),)

$(call warn-assign,CPPFLAGS)

KBUILD_CPPFLAGS += $(KCPPFLAGS)

endif

ifneq ($(KAFLAGS),)

$(call warn-assign,AFLAGS)

KBUILD_AFLAGS += $(KAFLAGS)

endif

ifneq ($(KCFLAGS),)

$(call warn-assign,CFLAGS)

KBUILD_CFLAGS += $(KCFLAGS)

endif

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

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_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

ifeq ($(KBUILD_EXTMOD),)

core-y += kernel/ 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)))

vmlinux-alldirs := $(sort $(vmlinux-dirs) $(patsubst %/,%,$(filter %/, \

$(init-n) $(init-) \

$(core-n) $(core-) $(drivers-n) $(drivers-) \

$(net-n) $(net-) $(libs-n) $(libs-))))

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)

# 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/$(SRCARCH)/kernel/vmlinux.lds

export KBUILD_VMLINUX_OBJS := $(vmlinux-all)

# 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) vmlinux.o 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

# Generate System.map

quiet_cmd_sysmap = SYSMAP

cmd_sysmap = $(CONFIG_SHELL) $(srctree)/scripts/mksysmap

# 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

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 'make KALLSYMS_EXTRA_PASS=1" was used, 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.

last_kallsyms := 2

ifdef KALLSYMS_EXTRA_PASS

ifneq ($(KALLSYMS_EXTRA_PASS),0)

last_kallsyms := 3

endif

endif

kallsyms.o := .tmp_kallsyms$(last_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 This is a bug - please report about it; \

echo Try "make KALLSYMS_EXTRA_PASS=1" as a workaround; \

rm .tmp_kallsyms* ; /bin/false )

endef

# 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

# Generate .S file with all kernel symbols

quiet_cmd_kallsyms = KSYM $@

cmd_kallsyms = $(NM) -n $< | $(KALLSYMS) \

$(if $(CONFIG_KALLSYMS_ALL),--all-symbols) > $@

.tmp_kallsyms1.o .tmp_kallsyms2.o .tmp_kallsyms3.o: %.o: %.S scripts FORCE

$(call if_changed_dep,as_o_S)

.tmp_kallsyms%.S: .tmp_vmlinux% $(KALLSYMS)

$(call cmd,kallsyms)

# .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_vmlinux2: $(vmlinux-lds) $(vmlinux-all) .tmp_kallsyms1.o FORCE

$(call if_changed,vmlinux__)

.tmp_vmlinux3: $(vmlinux-lds) $(vmlinux-all) .tmp_kallsyms2.o FORCE

$(call if_changed,vmlinux__)

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

.tmp_map%: .tmp_vmlinux% FORCE

($(OBJDUMP) -h $< | $(AWK) '/^ +[0-9]/{print $$4 " 0 " $$2}'; $(NM) $<) | sort > $@

.tmp_map3: .tmp_map2

.tmp_map2: .tmp_map1

endif # ifdef CONFIG_KALLSYMS

# Do modpost on a prelinked vmlinux. The finally linked vmlinux has

# relevant sections renamed as per the linker script.

quiet_cmd_vmlinux-modpost = LD $@

cmd_vmlinux-modpost = $(LD) $(LDFLAGS) -r -o $@ \

$(vmlinux-init) --start-group $(vmlinux-main) --end-group \

$(filter-out $(vmlinux-init) $(vmlinux-main) FORCE ,$^)

define rule_vmlinux-modpost

:

+$(call cmd,vmlinux-modpost)

$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modpost $@

$(Q)echo 'cmd_$@ := $(cmd_vmlinux-modpost)' > $(dot-target).cmd

endef

# vmlinux image - including updated kernel symbols

vmlinux: $(vmlinux-lds) $(vmlinux-init) $(vmlinux-main) vmlinux.o $(kallsyms.o) FORCE

ifdef CONFIG_HEADERS_CHECK

$(Q)$(MAKE) -f $(srctree)/Makefile headers_check

endif

ifdef CONFIG_SAMPLES

$(Q)$(MAKE) $(build)=samples

endif

ifdef CONFIG_BUILD_DOCSRC

$(Q)$(MAKE) $(build)=Documentation

endif

$(call vmlinux-modpost)

$(call if_changed_rule,vmlinux__)

$(Q)rm -f .old_version

# build vmlinux.o first to catch section mismatch errors early

ifdef CONFIG_KALLSYMS

.tmp_vmlinux1: vmlinux.o

endif

modpost-init := $(filter-out init/built-in.o, $(vmlinux-init))

vmlinux.o: $(modpost-init) $(vmlinux-main) FORCE

$(call if_changed_rule,vmlinux-modpost)

# The actual objects are generated when descending,

# make sure no implicit rule kicks in

$(sort $(vmlinux-init) $(vmlinux-main)) $(vmlinux-lds): $(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)=$@

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

include/config/kernel.release: include/config/auto.conf FORCE

$(Q)rm -f $@

$(Q)echo "$(KERNELVERSION)$$($(CONFIG_SHELL) $(srctree)/scripts/setlocalversion $(srctree))" > $@

# 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

# 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 " $(srctree) is not clean, please run 'make mrproper'";\

echo " in the '$(srctree)' directory.";\

/bin/false; \

fi;

endif

# prepare2 creates a makefile if using a separate output directory

prepare2: prepare3 outputmakefile asm-generic

prepare1: prepare2 include/linux/version.h include/generated/utsrelease.h \

include/config/auto.conf

$(cmd_crmodverdir)

archprepare: prepare1 scripts_basic

prepare0: archprepare FORCE

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

$(Q)$(MAKE) $(build)=. missing-syscalls

# All the preparing..

prepare: prepare0

# 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; \