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	------------
3	
4	The configuration database is a collection of configuration options
5	organized in a tree structure:
6	
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		+- ...
19	
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.
23	
24	Menu entries
25	------------
26	
27	Most entries define a config option; all other entries help to organize
28	them. A single configuration option is defined like this:
29	
30	config MODVERSIONS
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.  ...
36	
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.
44	
45	Menu attributes
46	---------------
47	
48	A menu entry can have a number of attributes. Not all of them are
49	applicable everywhere (see syntax).
50	
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:
56	
57		bool "Networking support"
58	  and
59		bool
60		prompt "Networking support"
61	
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".
66	
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".
79	
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".
84	
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:
90	
91		bool "foo" if BAR
92		default y if BAR
93	  and
94		depends on BAR
95		bool "foo"
96		default y
97	
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.
115	
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.
122	
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.
128	
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.
136	
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:
141	
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.)
146	
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.
151	
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).
159	
160	Menu dependencies
161	-----------------
162	
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:
167	
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)
175	
176	Expressions are listed in decreasing order of precedence. 
177	
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/).
189	
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'.
193	
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 '\'.
201	
202	Menu structure
203	--------------
204	
205	The position of a menu entry in the tree is determined in two ways. First
206	it can be specified explicitly:
207	
208	menu "Network device support"
209		depends on NET
210	
211	config NETDEVICES
212		...
213	
214	endmenu
215	
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.
220	
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
228	
229	config MODULES
230		bool "Enable loadable module support"
231	
232	config MODVERSIONS
233		bool "Set version information on all module symbols"
234		depends on MODULES
235	
236	comment "module support disabled"
237		depends on !MODULES
238	
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).
243	
244	
245	Kconfig syntax
246	--------------
247	
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.
259	
260	config:
261	
262		"config" <symbol>
263		<config options>
264	
265	This defines a config symbol <symbol> and accepts any of above
266	attributes as options.
267	
268	menuconfig:
269		"menuconfig" <symbol>
270		<config options>
271	
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.
275	
276	choices:
277	
278		"choice" [symbol]
279		<choice options>
280		<choice block>
281		"endchoice"
282	
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.
296	
297	comment:
298	
299		"comment" <prompt>
300		<comment options>
301	
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.
305	
306	menu:
307	
308		"menu" <prompt>
309		<menu options>
310		<menu block>
311		"endmenu"
312	
313	This defines a menu block, see "Menu structure" above for more
314	information. The only possible options are dependencies and "visible"
315	attributes.
316	
317	if:
318	
319		"if" <expr>
320		<if block>
321		"endif"
322	
323	This defines an if block. The dependency expression <expr> is appended
324	to all enclosed menu entries.
325	
326	source:
327	
328		"source" <prompt>
329	
330	This reads the specified configuration file. This file is always parsed.
331	
332	mainmenu:
333	
334		"mainmenu" <prompt>
335	
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.
339	
340	
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.
346	
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.
355	
356	We would in lib/Kconfig see:
357	
358	# Generic IOMAP is used to ...
359	config HAVE_GENERIC_IOMAP
360	
361	config GENERIC_IOMAP
362		depends on HAVE_GENERIC_IOMAP && FOO
363	
364	And in lib/Makefile we would see:
365	obj-$(CONFIG_GENERIC_IOMAP) += iomap.o
366	
367	For each architecture using the generic IOMAP functionality we would see:
368	
369	config X86
370		select ...
371		select HAVE_GENERIC_IOMAP
372		select ...
373	
374	Note: we use the existing config option and avoid creating a new
375	config variable to select HAVE_GENERIC_IOMAP.
376	
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'.
382	
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.:
387	
388	config FOO
389		depends on BAR && m
390	
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.