ar71xx: fix Kconfig symbol selection for RB95x/RB2011
[openwrt.git] / Config-kernel.in
1 config KERNEL_DEBUG_FS
2         bool "Compile the kernel with Debug FileSystem enabled"
3         default y
4         help
5           debugfs is a virtual file system that kernel developers use to put
6           debugging files into. Enable this option to be able to read and
7           write to these files.
8
9 config KERNEL_PERF_EVENTS
10         bool
11         default n
12
13 config KERNEL_PROFILING
14         bool "Compile the kernel with profiling enabled"
15         default n
16         select KERNEL_PERF_EVENTS
17         help
18           Enable the extended profiling support mechanisms used by profilers such
19           as OProfile.
20
21 config KERNEL_KALLSYMS
22         bool "Compile the kernel with symbol table information"
23         default y
24         help
25           This will give you more information in stack traces from kernel oopses
26
27 config KERNEL_FTRACE
28         bool "Compile the kernel with tracing support"
29         default n
30
31 config KERNEL_FTRACE_SYSCALLS
32         bool "Trace system calls"
33         depends on KERNEL_FTRACE
34         default n
35
36 config KERNEL_ENABLE_DEFAULT_TRACERS
37         bool "Trace process context switches and events"
38         depends on KERNEL_FTRACE
39         default n
40
41 config KERNEL_DEBUG_KERNEL
42         bool
43         default n
44
45 config KERNEL_DEBUG_INFO
46         bool "Compile the kernel with debug information"
47         default y
48         select KERNEL_DEBUG_KERNEL
49         help
50           This will compile your kernel and modules with debug information.
51
52 config KERNEL_DEBUG_LL_UART_NONE
53         bool
54         default n
55         depends on arm
56
57 config KERNEL_DEBUG_LL
58         bool
59         default n
60         depends on arm
61         select KERNEL_DEBUG_LL_UART_NONE
62         help
63           ARM low level debugging
64
65 config KERNEL_EARLY_PRINTK
66         bool "Compile the kernel with early printk"
67         default n
68         depends on arm
69         select KERNEL_DEBUG_KERNEL
70         select KERNEL_DEBUG_LL if arm
71         help
72           Compile the kernel with early printk support.
73           This is only useful for debugging purposes to send messages
74           over the serial console in early boot.
75           Enable this to debug early boot problems.
76
77 config KERNEL_AIO
78         bool "Compile the kernel with asynchronous IO support"
79         default n
80
81 config KERNEL_DIRECT_IO
82         bool "Compile the kernel with direct IO support"
83         default n
84
85 config KERNEL_MAGIC_SYSRQ
86         bool "Compile the kernel with SysRq support"
87         default y
88
89 config KERNEL_COREDUMP
90         bool
91
92 config KERNEL_ELF_CORE
93         bool "Enable process core dump support"
94         select KERNEL_COREDUMP
95         default y
96
97 config KERNEL_PROVE_LOCKING
98         bool "Enable kernel lock checking"
99         select KERNEL_DEBUG_KERNEL
100         default n
101
102 config KERNEL_PRINTK_TIME
103         bool "Enable printk timestamps"
104         default y
105
106 config KERNEL_RELAY
107         bool
108
109 config KERNEL_KEXEC
110         bool "Enable kexec support"
111
112 config USE_RFKILL
113         bool "Enable rfkill support"
114         default RFKILL_SUPPORT
115
116 #
117 # CGROUP support symbols
118 #
119
120 config KERNEL_CGROUPS
121         bool "Enable kernel cgroups"
122         default n
123
124 if KERNEL_CGROUPS
125
126         config KERNEL_CGROUP_DEBUG
127                 bool "Example debug cgroup subsystem"
128                 default n
129                 help
130                   This option enables a simple cgroup subsystem that
131                   exports useful debugging information about the cgroups
132                   framework.
133
134         config KERNEL_FREEZER
135                 bool
136                 default y if KERNEL_CGROUP_FREEZER
137
138         config KERNEL_CGROUP_FREEZER
139                 bool "Freezer cgroup subsystem"
140                 default n
141                 help
142                   Provides a way to freeze and unfreeze all tasks in a
143                   cgroup.
144
145         config KERNEL_CGROUP_DEVICE
146                 bool "Device controller for cgroups"
147                 default y
148                 help
149                   Provides a cgroup implementing whitelists for devices which
150                   a process in the cgroup can mknod or open.
151
152         config KERNEL_CPUSETS
153                 bool "Cpuset support"
154                 default n
155                 help
156                   This option will let you create and manage CPUSETs which
157                   allow dynamically partitioning a system into sets of CPUs and
158                   Memory Nodes and assigning tasks to run only within those sets.
159                   This is primarily useful on large SMP or NUMA systems.
160
161         config KERNEL_PROC_PID_CPUSET
162                 bool "Include legacy /proc/<pid>/cpuset file"
163                 default n
164                 depends on KERNEL_CPUSETS
165
166         config KERNEL_CGROUP_CPUACCT
167                 bool "Simple CPU accounting cgroup subsystem"
168                 default n
169                 help
170                   Provides a simple Resource Controller for monitoring the
171                   total CPU consumed by the tasks in a cgroup.
172
173         config KERNEL_RESOURCE_COUNTERS
174                 bool "Resource counters"
175                 default n
176                 help
177                   This option enables controller independent resource accounting
178                   infrastructure that works with cgroups.
179
180         config KERNEL_MM_OWNER
181                 bool
182                 default y if KERNEL_MEMCG
183
184         config KERNEL_MEMCG
185                 bool "Memory Resource Controller for Control Groups"
186                 default n
187                 depends on KERNEL_RESOURCE_COUNTERS
188                 help
189                   Provides a memory resource controller that manages both anonymous
190                   memory and page cache. (See Documentation/cgroups/memory.txt)
191
192                   Note that setting this option increases fixed memory overhead
193                   associated with each page of memory in the system. By this,
194                   20(40)bytes/PAGE_SIZE on 32(64)bit system will be occupied by memory
195                   usage tracking struct at boot. Total amount of this is printed out
196                   at boot.
197
198                   Only enable when you're ok with these trade offs and really
199                   sure you need the memory resource controller. Even when you enable
200                   this, you can set "cgroup_disable=memory" at your boot option to
201                   disable memory resource controller and you can avoid overheads.
202                   (and lose benefits of memory resource controller)
203
204                   This config option also selects MM_OWNER config option, which
205                   could in turn add some fork/exit overhead.
206
207         config KERNEL_MEMCG_SWAP
208                 bool "Memory Resource Controller Swap Extension"
209                 default n
210                 depends on KERNEL_MEMCG
211                 help
212                   Add swap management feature to memory resource controller. When you
213                   enable this, you can limit mem+swap usage per cgroup. In other words,
214                   when you disable this, memory resource controller has no cares to
215                   usage of swap...a process can exhaust all of the swap. This extension
216                   is useful when you want to avoid exhaustion swap but this itself
217                   adds more overheads and consumes memory for remembering information.
218                   Especially if you use 32bit system or small memory system, please
219                   be careful about enabling this. When memory resource controller
220                   is disabled by boot option, this will be automatically disabled and
221                   there will be no overhead from this. Even when you set this config=y,
222                   if boot option "swapaccount=0" is set, swap will not be accounted.
223                   Now, memory usage of swap_cgroup is 2 bytes per entry. If swap page
224                   size is 4096bytes, 512k per 1Gbytes of swap.
225
226         config KERNEL_MEMCG_SWAP_ENABLED
227                 bool "Memory Resource Controller Swap Extension enabled by default"
228                 default n
229                 depends on KERNEL_MEMCG_SWAP
230                 help
231                   Memory Resource Controller Swap Extension comes with its price in
232                   a bigger memory consumption. General purpose distribution kernels
233                   which want to enable the feature but keep it disabled by default
234                   and let the user enable it by swapaccount boot command line
235                   parameter should have this option unselected.
236                   For those who want to have the feature enabled by default should
237                   select this option (if, for some reason, they need to disable it
238                   then swapaccount=0 does the trick).
239
240
241         config KERNEL_MEMCG_KMEM
242                 bool "Memory Resource Controller Kernel Memory accounting (EXPERIMENTAL)"
243                 default n
244                 depends on KERNEL_MEMCG
245                 help
246                   The Kernel Memory extension for Memory Resource Controller can limit
247                   the amount of memory used by kernel objects in the system. Those are
248                   fundamentally different from the entities handled by the standard
249                   Memory Controller, which are page-based, and can be swapped. Users of
250                   the kmem extension can use it to guarantee that no group of processes
251                   will ever exhaust kernel resources alone.
252
253         config KERNEL_PERF_EVENTS
254                 bool
255                 default y if KERNEL_CGROUP_PERF
256
257         config KERNEL_CGROUP_PERF
258                 bool "Enable perf_event per-cpu per-container group (cgroup) monitoring"
259                 default n
260                 help
261                   This option extends the per-cpu mode to restrict monitoring to
262                   threads which belong to the cgroup specified and run on the
263                   designated cpu.
264
265         menuconfig KERNEL_CGROUP_SCHED
266                 bool "Group CPU scheduler"
267                 default n
268                 help
269                   This feature lets CPU scheduler recognize task groups and control CPU
270                   bandwidth allocation to such task groups. It uses cgroups to group
271                   tasks.
272
273         if KERNEL_CGROUP_SCHED
274
275                 config KERNEL_FAIR_GROUP_SCHED
276                         bool "Group scheduling for SCHED_OTHER"
277                         default n
278
279                 config KERNEL_CFS_BANDWIDTH
280                         bool "CPU bandwidth provisioning for FAIR_GROUP_SCHED"
281                         default n
282                         depends on KERNEL_FAIR_GROUP_SCHED
283                         help
284                           This option allows users to define CPU bandwidth rates (limits) for
285                           tasks running within the fair group scheduler.  Groups with no limit
286                           set are considered to be unconstrained and will run with no
287                           restriction.
288                           See tip/Documentation/scheduler/sched-bwc.txt for more information.
289
290                 config KERNEL_RT_GROUP_SCHED
291                         bool "Group scheduling for SCHED_RR/FIFO"
292                         default n
293                         help
294                           This feature lets you explicitly allocate real CPU bandwidth
295                           to task groups. If enabled, it will also make it impossible to
296                           schedule realtime tasks for non-root users until you allocate
297                           realtime bandwidth for them.
298
299         endif
300
301         config KERNEL_BLK_CGROUP
302                 bool "Block IO controller"
303                 default y
304                 help
305                   Generic block IO controller cgroup interface. This is the common
306                   cgroup interface which should be used by various IO controlling
307                   policies.
308
309                   Currently, CFQ IO scheduler uses it to recognize task groups and
310                   control disk bandwidth allocation (proportional time slice allocation)
311                   to such task groups. It is also used by bio throttling logic in
312                   block layer to implement upper limit in IO rates on a device.
313
314                   This option only enables generic Block IO controller infrastructure.
315                   One needs to also enable actual IO controlling logic/policy. For
316                   enabling proportional weight division of disk bandwidth in CFQ, set
317                   CONFIG_CFQ_GROUP_IOSCHED=y; for enabling throttling policy, set
318                   CONFIG_BLK_DEV_THROTTLING=y.
319
320         config KERNEL_DEBUG_BLK_CGROUP
321                 bool "Enable Block IO controller debugging"
322                 default n
323                 depends on KERNEL_BLK_CGROUP
324                 help
325                   Enable some debugging help. Currently it exports additional stat
326                   files in a cgroup which can be useful for debugging.
327
328         config KERNEL_NET_CLS_CGROUP
329                 bool "Control Group Classifier"
330                 default y
331
332         config KERNEL_NETPRIO_CGROUP
333                 bool "Network priority cgroup"
334                 default y
335
336 endif
337
338 #
339 # Namespace support symbols
340 #
341
342 config KERNEL_NAMESPACES
343         bool "Enable kernel namespaces"
344         default n
345
346 if KERNEL_NAMESPACES
347
348         config KERNEL_UTS_NS
349                 bool "UTS namespace"
350                 default y
351                 help
352                   In this namespace tasks see different info provided
353                   with the uname() system call
354
355         config KERNEL_IPC_NS
356                 bool "IPC namespace"
357                 default y
358                 help
359                   In this namespace tasks work with IPC ids which correspond to
360                   different IPC objects in different namespaces.
361
362         config KERNEL_USER_NS
363                 bool "User namespace (EXPERIMENTAL)"
364                 default y
365                 help
366                   This allows containers, i.e. vservers, to use user namespaces
367                   to provide different user info for different servers.
368
369         config KERNEL_PID_NS
370                 bool "PID Namespaces"
371                 default y
372                 help
373                   Support process id namespaces. This allows having multiple
374                   processes with the same pid as long as they are in different
375                   pid namespaces. This is a building block of containers.
376
377         config KERNEL_NET_NS
378                 bool "Network namespace"
379                 default y
380                 help
381                   Allow user space to create what appear to be multiple instances
382                   of the network stack.
383
384 endif
385
386 #
387 # LXC related symbols
388 #
389
390 config KERNEL_LXC_MISC
391         bool "Enable miscellaneous LXC related options"
392         default n
393
394 if KERNEL_LXC_MISC
395
396         config KERNEL_DEVPTS_MULTIPLE_INSTANCES
397                 bool "Support multiple instances of devpts"
398                 default y
399                 help
400                   Enable support for multiple instances of devpts filesystem.
401                   If you want to have isolated PTY namespaces (eg: in containers),
402                   say Y here. Otherwise, say N. If enabled, each mount of devpts
403                   filesystem with the '-o newinstance' option will create an
404                   independent PTY namespace.
405
406         config KERNEL_POSIX_MQUEUE
407                 bool "POSIX Message Queues"
408                 default n
409                 help
410                   POSIX variant of message queues is a part of IPC. In POSIX message
411                   queues every message has a priority which decides about succession
412                   of receiving it by a process. If you want to compile and run
413                   programs written e.g. for Solaris with use of its POSIX message
414                   queues (functions mq_*) say Y here.
415
416                   POSIX message queues are visible as a filesystem called 'mqueue'
417                   and can be mounted somewhere if you want to do filesystem
418                   operations on message queues.
419
420 endif