Merge git://git.kernel.org/pub/scm/linux/kernel/git/sam/kbuild

*.i

*.lst

*.symtypes

*.order

#

# Top-level generic files

Menu entries

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

Most entries define a config option, all other entries help to organize

Most entries define a config option; all other entries help to organize

them. A single configuration option is defined like this:

config MODVERSIONS

- type definition: "bool"/"tristate"/"string"/"hex"/"int"

  Every config option must have a type. There are only two basic types:

  tristate and string, the other types are based on these two. The type

  tristate and string; the other types are based on these two. The type

  definition optionally accepts an input prompt, so these two examples

  are equivalent:

	equal to 'y' without visiting the dependencies. So abusing

	select you are able to select a symbol FOO even if FOO depends

	on BAR that is not set. In general use select only for

	non-visible symbols (no promts anywhere) and for symbols with

	non-visible symbols (no prompts anywhere) and for symbols with

	no dependencies. That will limit the usefulness but on the

	other hand avoid the illegal configurations all over. kconfig

	should one day warn about such things.

  used to help visually separate configuration logic from help within

  the file as an aid to developers.

- misc options: "option" <symbol>[=<value>]

  Various less common options can be defined via this option syntax,

  which can modify the behaviour of the menu entry and its config

  symbol. These options are currently possible:

  - "defconfig_list"

    This declares a list of default entries which can be used when

    looking for the default configuration (which is used when the main

    .config doesn't exists yet.)

  - "modules"

    This declares the symbol to be used as the MODULES symbol, which

    enables the third modular state for all config symbols.

  - "env"=<value>

    This imports the environment variable into Kconfig. It behaves like

    a default, except that the value comes from the environment, this

    also means that the behaviour when mixing it with normal defaults is

    undefined at this point. The symbol is currently not exported back

    to the build environment (if this is desired, it can be done via

    another symbol).

Menu dependencies

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

respectively for calculations). A menu entry becomes visible when it's

expression evaluates to 'm' or 'y'.

There are two types of symbols: constant and nonconstant symbols.

Nonconstant symbols are the most common ones and are defined with the

'config' statement. Nonconstant symbols consist entirely of alphanumeric

There are two types of symbols: constant and non-constant symbols.

Non-constant symbols are the most common ones and are defined with the

'config' statement. Non-constant symbols consist entirely of alphanumeric

characters or underscores.

Constant symbols are only part of expressions. Constant symbols are

always surrounded by single or double quotes. Within the quote, any

This sets the config program's title bar if the config program chooses

to use it.

Kconfig hints

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

This is a collection of Kconfig tips, most of which aren't obvious at

first glance and most of which have become idioms in several Kconfig

files.

Adding common features and make the usage configurable

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

It is a common idiom to implement a feature/functionality that are

relevant for some architectures but not all.

The recommended way to do so is to use a config variable named HAVE_*

that is defined in a common Kconfig file and selected by the relevant

architectures.

An example is the generic IOMAP functionality.

We would in lib/Kconfig see:

# Generic IOMAP is used to ...

config HAVE_GENERIC_IOMAP

config GENERIC_IOMAP

	depends on HAVE_GENERIC_IOMAP && FOO

And in lib/Makefile we would see:

obj-$(CONFIG_GENERIC_IOMAP) += iomap.o

For each architecture using the generic IOMAP functionality we would see:

config X86

	select ...

	select HAVE_GENERIC_IOMAP

	select ...

Note: we use the existing config option and avoid creating a new

config variable to select HAVE_GENERIC_IOMAP.

Note: the use of the internal config variable HAVE_GENERIC_IOMAP, it is

introduced to overcome the limitation of select which will force a

config option to 'y' no matter the dependencies.

The dependencies are moved to the symbol GENERIC_IOMAP and we avoid the

situation where select forces a symbol equals to 'y'.

Build as module only

~~~~~~~~~~~~~~~~~~~~

To restrict a component build to module-only, qualify its config symbol

with "depends on m".  E.g.:

config FOO

	depends on BAR && m

limits FOO to module (=m) or disabled (=n).

Build limited by a third config symbol which may be =y or =m

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

A common idiom that we see (and sometimes have problems with) is this:

When option C in B (module or subsystem) uses interfaces from A (module

or subsystem), and both A and B are tristate (could be =y or =m if they

were independent of each other, but they aren't), then we need to limit

C such that it cannot be built statically if A is built as a loadable

module.  (C already depends on B, so there is no dependency issue to

take care of here.)

If A is linked statically into the kernel image, C can be built

statically or as loadable module(s).  However, if A is built as loadable

module(s), then C must be restricted to loadable module(s) also.  This

can be expressed in kconfig language as:

config C

	depends on A = y || A = B

or for real examples, use this command in a kernel tree:

$ find . -name Kconfig\* | xargs grep -ns "depends on.*=.*||.*=" | grep -v orig

KBUILD_AFLAGS	+= -gdwarf-2

endif

# We trigger additional mismatches with less inlining

ifdef CONFIG_DEBUG_SECTION_MISMATCH

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

endif

# Force gcc to behave correct even for buggy distributions

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

endef

# vmlinux image - including updated kernel symbols

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

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

ifdef CONFIG_HEADERS_CHECK

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

endif

	$(call if_changed_rule,vmlinux__)

	$(Q)rm -f .old_version

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

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

$(kallsyms.o): vmlinux.o

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

	$(call if_changed_rule,vmlinux-modpost)

# The actual objects are generated when descending, 

all: modules

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

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

	@echo '  Building modules, stage 2.';

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

		rm -f $(MODLIB)/build ; \

		ln -s $(objtree) $(MODLIB)/build ; \

	fi

	@cp -f $(objtree)/modules.order $(MODLIB)/

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

# This depmod is only for convenience to give the initial

	@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' \) \

		-o -name '*.symtypes' -o -name 'modules.order' \) \

		-type f -print | xargs rm -f

# mrproper - Delete all generated files, including .config

	@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  '  prepare         - Set up for building external modules'

	@echo  '  tags/TAGS	  - Generate tags file for editors'

	@echo  '  cscope	  - Generate cscope index'

	@echo  '  kernelrelease	  - Output the release version string'

	@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'

	@if [ -r $(srctree)/include/asm-$(SRCARCH)/Kbuild ]; then \

	 echo  '  headers_check   - Sanity check on exported headers'; \

	if $1 --version 2>&1 | grep -iq exuberant; then \

	    $(all-sources) | xargs $1 -a \

		-I __initdata,__exitdata,__acquires,__releases \

		-I __read_mostly,____cacheline_aligned,____cacheline_aligned_in_smp,____cacheline_internodealigned_in_smp \

		-I EXPORT_SYMBOL,EXPORT_SYMBOL_GPL \

		--extra=+f --c-kinds=+px \

		--regex-asm='/^ENTRY\(([^)]*)\).*/\1/'; \

includecheck:

	find * $(RCS_FIND_IGNORE) \

		-name '*.[hcS]' -type f -print | sort \

		| xargs $(PERL) -w scripts/checkincludes.pl

		| xargs $(PERL) -w $(srctree)/scripts/checkincludes.pl

versioncheck:

	find * $(RCS_FIND_IGNORE) \

		-name '*.[hcS]' -type f -print | sort \

		| xargs $(PERL) -w scripts/checkversion.pl

		| xargs $(PERL) -w $(srctree)/scripts/checkversion.pl

namespacecheck:

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

	__init_begin = .;

	.init.text : {

		_sinittext = .;

		*(.init.text)

		INIT_TEXT

		_einittext = .;

	}

	.init.data : {

		*(.init.data)

		INIT_DATA

	}

	. = ALIGN(16);

	/* Sections to be discarded */

	/DISCARD/ : {

		*(.exit.text)

		*(.exit.data)

		EXIT_TEXT

		EXIT_DATA

		*(.exitcall.exit)

	}

	.previous				\n\

	.end _atomic_dec_and_lock");

static int __attribute_used__

atomic_dec_and_lock_1(atomic_t *atomic, spinlock_t *lock)

static int __used atomic_dec_and_lock_1(atomic_t *atomic, spinlock_t *lock)

{

	/* Slow path */

	spin_lock(lock);