About Kernel Documentation Linux Kernel Contact Linux Resources Linux Blog

Documentation / kbuild / kconfig-language.txt

Custom Search

Based on kernel version 3.13. Page generated on 2014-01-20 22:03 EST.

1	Introduction
2	------------
4	The configuration database is a collection of configuration options
5	organized in a tree structure:
7		+- Code maturity level options
8		|  +- Prompt for development and/or incomplete code/drivers
9		+- General setup
10		|  +- Networking support
11		|  +- System V IPC
12		|  +- BSD Process Accounting
13		|  +- Sysctl support
14		+- Loadable module support
15		|  +- Enable loadable module support
16		|     +- Set version information on all module symbols
17		|     +- Kernel module loader
18		+- ...
20	Every entry has its own dependencies. These dependencies are used
21	to determine the visibility of an entry. Any child entry is only
22	visible if its parent entry is also visible.
24	Menu entries
25	------------
27	Most entries define a config option; all other entries help to organize
28	them. A single configuration option is defined like this:
31		bool "Set version information on all module symbols"
32		depends on MODULES
33		help
34		  Usually, modules have to be recompiled whenever you switch to a new
35		  kernel.  ...
37	Every line starts with a key word and can be followed by multiple
38	arguments.  "config" starts a new config entry. The following lines
39	define attributes for this config option. Attributes can be the type of
40	the config option, input prompt, dependencies, help text and default
41	values. A config option can be defined multiple times with the same
42	name, but every definition can have only a single input prompt and the
43	type must not conflict.
45	Menu attributes
46	---------------
48	A menu entry can have a number of attributes. Not all of them are
49	applicable everywhere (see syntax).
51	- type definition: "bool"/"tristate"/"string"/"hex"/"int"
52	  Every config option must have a type. There are only two basic types:
53	  tristate and string; the other types are based on these two. The type
54	  definition optionally accepts an input prompt, so these two examples
55	  are equivalent:
57		bool "Networking support"
58	  and
59		bool
60		prompt "Networking support"
62	- input prompt: "prompt" <prompt> ["if" <expr>]
63	  Every menu entry can have at most one prompt, which is used to display
64	  to the user. Optionally dependencies only for this prompt can be added
65	  with "if".
67	- default value: "default" <expr> ["if" <expr>]
68	  A config option can have any number of default values. If multiple
69	  default values are visible, only the first defined one is active.
70	  Default values are not limited to the menu entry where they are
71	  defined. This means the default can be defined somewhere else or be
72	  overridden by an earlier definition.
73	  The default value is only assigned to the config symbol if no other
74	  value was set by the user (via the input prompt above). If an input
75	  prompt is visible the default value is presented to the user and can
76	  be overridden by him.
77	  Optionally, dependencies only for this default value can be added with
78	  "if".
80	- type definition + default value:
81		"def_bool"/"def_tristate" <expr> ["if" <expr>]
82	  This is a shorthand notation for a type definition plus a value.
83	  Optionally dependencies for this default value can be added with "if".
85	- dependencies: "depends on" <expr>
86	  This defines a dependency for this menu entry. If multiple
87	  dependencies are defined, they are connected with '&&'. Dependencies
88	  are applied to all other options within this menu entry (which also
89	  accept an "if" expression), so these two examples are equivalent:
91		bool "foo" if BAR
92		default y if BAR
93	  and
94		depends on BAR
95		bool "foo"
96		default y
98	- reverse dependencies: "select" <symbol> ["if" <expr>]
99	  While normal dependencies reduce the upper limit of a symbol (see
100	  below), reverse dependencies can be used to force a lower limit of
101	  another symbol. The value of the current menu symbol is used as the
102	  minimal value <symbol> can be set to. If <symbol> is selected multiple
103	  times, the limit is set to the largest selection.
104	  Reverse dependencies can only be used with boolean or tristate
105	  symbols.
106	  Note:
107		select should be used with care. select will force
108		a symbol to a value without visiting the dependencies.
109		By abusing select you are able to select a symbol FOO even
110		if FOO depends on BAR that is not set.
111		In general use select only for non-visible symbols
112		(no prompts anywhere) and for symbols with no dependencies.
113		That will limit the usefulness but on the other hand avoid
114		the illegal configurations all over.
116	- limiting menu display: "visible if" <expr>
117	  This attribute is only applicable to menu blocks, if the condition is
118	  false, the menu block is not displayed to the user (the symbols
119	  contained there can still be selected by other symbols, though). It is
120	  similar to a conditional "prompt" attribute for individual menu
121	  entries. Default value of "visible" is true.
123	- numerical ranges: "range" <symbol> <symbol> ["if" <expr>]
124	  This allows to limit the range of possible input values for int
125	  and hex symbols. The user can only input a value which is larger than
126	  or equal to the first symbol and smaller than or equal to the second
127	  symbol.
129	- help text: "help" or "---help---"
130	  This defines a help text. The end of the help text is determined by
131	  the indentation level, this means it ends at the first line which has
132	  a smaller indentation than the first line of the help text.
133	  "---help---" and "help" do not differ in behaviour, "---help---" is
134	  used to help visually separate configuration logic from help within
135	  the file as an aid to developers.
137	- misc options: "option" <symbol>[=<value>]
138	  Various less common options can be defined via this option syntax,
139	  which can modify the behaviour of the menu entry and its config
140	  symbol. These options are currently possible:
142	  - "defconfig_list"
143	    This declares a list of default entries which can be used when
144	    looking for the default configuration (which is used when the main
145	    .config doesn't exists yet.)
147	  - "modules"
148	    This declares the symbol to be used as the MODULES symbol, which
149	    enables the third modular state for all config symbols.
150	    At most one symbol may have the "modules" option set.
152	  - "env"=<value>
153	    This imports the environment variable into Kconfig. It behaves like
154	    a default, except that the value comes from the environment, this
155	    also means that the behaviour when mixing it with normal defaults is
156	    undefined at this point. The symbol is currently not exported back
157	    to the build environment (if this is desired, it can be done via
158	    another symbol).
160	Menu dependencies
161	-----------------
163	Dependencies define the visibility of a menu entry and can also reduce
164	the input range of tristate symbols. The tristate logic used in the
165	expressions uses one more state than normal boolean logic to express the
166	module state. Dependency expressions have the following syntax:
168	<expr> ::= <symbol>                             (1)
169	           <symbol> '=' <symbol>                (2)
170	           <symbol> '!=' <symbol>               (3)
171	           '(' <expr> ')'                       (4)
172	           '!' <expr>                           (5)
173	           <expr> '&&' <expr>                   (6)
174	           <expr> '||' <expr>                   (7)
176	Expressions are listed in decreasing order of precedence. 
178	(1) Convert the symbol into an expression. Boolean and tristate symbols
179	    are simply converted into the respective expression values. All
180	    other symbol types result in 'n'.
181	(2) If the values of both symbols are equal, it returns 'y',
182	    otherwise 'n'.
183	(3) If the values of both symbols are equal, it returns 'n',
184	    otherwise 'y'.
185	(4) Returns the value of the expression. Used to override precedence.
186	(5) Returns the result of (2-/expr/).
187	(6) Returns the result of min(/expr/, /expr/).
188	(7) Returns the result of max(/expr/, /expr/).
190	An expression can have a value of 'n', 'm' or 'y' (or 0, 1, 2
191	respectively for calculations). A menu entry becomes visible when its
192	expression evaluates to 'm' or 'y'.
194	There are two types of symbols: constant and non-constant symbols.
195	Non-constant symbols are the most common ones and are defined with the
196	'config' statement. Non-constant symbols consist entirely of alphanumeric
197	characters or underscores.
198	Constant symbols are only part of expressions. Constant symbols are
199	always surrounded by single or double quotes. Within the quote, any
200	other character is allowed and the quotes can be escaped using '\'.
202	Menu structure
203	--------------
205	The position of a menu entry in the tree is determined in two ways. First
206	it can be specified explicitly:
208	menu "Network device support"
209		depends on NET
211	config NETDEVICES
212		...
214	endmenu
216	All entries within the "menu" ... "endmenu" block become a submenu of
217	"Network device support". All subentries inherit the dependencies from
218	the menu entry, e.g. this means the dependency "NET" is added to the
219	dependency list of the config option NETDEVICES.
221	The other way to generate the menu structure is done by analyzing the
222	dependencies. If a menu entry somehow depends on the previous entry, it
223	can be made a submenu of it. First, the previous (parent) symbol must
224	be part of the dependency list and then one of these two conditions
225	must be true:
226	- the child entry must become invisible, if the parent is set to 'n'
227	- the child entry must only be visible, if the parent is visible
229	config MODULES
230		bool "Enable loadable module support"
232	config MODVERSIONS
233		bool "Set version information on all module symbols"
234		depends on MODULES
236	comment "module support disabled"
237		depends on !MODULES
239	MODVERSIONS directly depends on MODULES, this means it's only visible if
240	MODULES is different from 'n'. The comment on the other hand is always
241	visible when MODULES is visible (the (empty) dependency of MODULES is
242	also part of the comment dependencies).
245	Kconfig syntax
246	--------------
248	The configuration file describes a series of menu entries, where every
249	line starts with a keyword (except help texts). The following keywords
250	end a menu entry:
251	- config
252	- menuconfig
253	- choice/endchoice
254	- comment
255	- menu/endmenu
256	- if/endif
257	- source
258	The first five also start the definition of a menu entry.
260	config:
262		"config" <symbol>
263		<config options>
265	This defines a config symbol <symbol> and accepts any of above
266	attributes as options.
268	menuconfig:
269		"menuconfig" <symbol>
270		<config options>
272	This is similar to the simple config entry above, but it also gives a
273	hint to front ends, that all suboptions should be displayed as a
274	separate list of options.
276	choices:
278		"choice" [symbol]
279		<choice options>
280		<choice block>
281		"endchoice"
283	This defines a choice group and accepts any of the above attributes as
284	options. A choice can only be of type bool or tristate, while a boolean
285	choice only allows a single config entry to be selected, a tristate
286	choice also allows any number of config entries to be set to 'm'. This
287	can be used if multiple drivers for a single hardware exists and only a
288	single driver can be compiled/loaded into the kernel, but all drivers
289	can be compiled as modules.
290	A choice accepts another option "optional", which allows to set the
291	choice to 'n' and no entry needs to be selected.
292	If no [symbol] is associated with a choice, then you can not have multiple
293	definitions of that choice. If a [symbol] is associated to the choice,
294	then you may define the same choice (ie. with the same entries) in another
295	place.
297	comment:
299		"comment" <prompt>
300		<comment options>
302	This defines a comment which is displayed to the user during the
303	configuration process and is also echoed to the output files. The only
304	possible options are dependencies.
306	menu:
308		"menu" <prompt>
309		<menu options>
310		<menu block>
311		"endmenu"
313	This defines a menu block, see "Menu structure" above for more
314	information. The only possible options are dependencies and "visible"
315	attributes.
317	if:
319		"if" <expr>
320		<if block>
321		"endif"
323	This defines an if block. The dependency expression <expr> is appended
324	to all enclosed menu entries.
326	source:
328		"source" <prompt>
330	This reads the specified configuration file. This file is always parsed.
332	mainmenu:
334		"mainmenu" <prompt>
336	This sets the config program's title bar if the config program chooses
337	to use it. It should be placed at the top of the configuration, before any
338	other statement.
341	Kconfig hints
342	-------------
343	This is a collection of Kconfig tips, most of which aren't obvious at
344	first glance and most of which have become idioms in several Kconfig
345	files.
347	Adding common features and make the usage configurable
348	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
349	It is a common idiom to implement a feature/functionality that are
350	relevant for some architectures but not all.
351	The recommended way to do so is to use a config variable named HAVE_*
352	that is defined in a common Kconfig file and selected by the relevant
353	architectures.
354	An example is the generic IOMAP functionality.
356	We would in lib/Kconfig see:
358	# Generic IOMAP is used to ...
361	config GENERIC_IOMAP
362		depends on HAVE_GENERIC_IOMAP && FOO
364	And in lib/Makefile we would see:
365	obj-$(CONFIG_GENERIC_IOMAP) += iomap.o
367	For each architecture using the generic IOMAP functionality we would see:
369	config X86
370		select ...
372		select ...
374	Note: we use the existing config option and avoid creating a new
375	config variable to select HAVE_GENERIC_IOMAP.
377	Note: the use of the internal config variable HAVE_GENERIC_IOMAP, it is
378	introduced to overcome the limitation of select which will force a
379	config option to 'y' no matter the dependencies.
380	The dependencies are moved to the symbol GENERIC_IOMAP and we avoid the
381	situation where select forces a symbol equals to 'y'.
383	Build as module only
384	~~~~~~~~~~~~~~~~~~~~
385	To restrict a component build to module-only, qualify its config symbol
386	with "depends on m".  E.g.:
388	config FOO
389		depends on BAR && m
391	limits FOO to module (=m) or disabled (=n).
Hide Line Numbers
About Kernel Documentation Linux Kernel Contact Linux Resources Linux Blog

Information is copyright its respective author. All material is available from the Linux Kernel Source distributed under a GPL License. This page is provided as a free service by mjmwired.net.