OSDN Git Service

5e12ddd78d8d75ed3048c333b5e36c6be90c9a25
[immortalwrt/immortalwrt.git] / config / Config-kernel.in
1 # SPDX-License-Identifier: GPL-2.0-only
2 #
3 # Copyright (C) 2006-2014 OpenWrt.org
4
5 config KERNEL_BUILD_USER
6         string "Custom Kernel Build User Name"
7         default "builder" if BUILDBOT
8         default ""
9         help
10           Sets the Kernel build user string, which for example will be returned
11           by 'uname -a' on running systems.
12           If not set, uses system user at build time.
13
14 config KERNEL_BUILD_DOMAIN
15         string "Custom Kernel Build Domain Name"
16         default "buildhost" if BUILDBOT
17         default ""
18         help
19           Sets the Kernel build domain string, which for example will be
20           returned by 'uname -a' on running systems.
21           If not set, uses system hostname at build time.
22
23 config KERNEL_PRINTK
24         bool "Enable support for printk"
25         default y
26
27 config KERNEL_SWAP
28         bool "Support for paging of anonymous memory (swap)"
29         default y if !SMALL_FLASH
30
31 config KERNEL_PROC_STRIPPED
32         bool "Strip non-essential /proc functionality to reduce code size"
33         default y if SMALL_FLASH
34
35 config KERNEL_DEBUG_FS
36         bool "Compile the kernel with debug filesystem enabled"
37         default y
38         help
39           debugfs is a virtual file system that kernel developers use to put
40           debugging files into. Enable this option to be able to read and
41           write to these files. Many common debugging facilities, such as
42           ftrace, require the existence of debugfs.
43
44 config KERNEL_MIPS_FP_SUPPORT
45         bool
46         default y if TARGET_pistachio
47
48 config KERNEL_ARM_PMU
49         bool
50         default n
51         depends on (arm || aarch64)
52
53 config KERNEL_X86_VSYSCALL_EMULATION
54         bool "Enable vsyscall emulation"
55         default n
56         depends on x86_64
57         help
58           This enables emulation of the legacy vsyscall page.  Disabling
59           it is roughly equivalent to booting with vsyscall=none, except
60           that it will also disable the helpful warning if a program
61           tries to use a vsyscall.  With this option set to N, offending
62           programs will just segfault, citing addresses of the form
63           0xffffffffff600?00.
64
65           This option is required by many programs built before 2013, and
66           care should be used even with newer programs if set to N.
67
68           Disabling this option saves about 7K of kernel size and
69           possibly 4K of additional runtime pagetable memory.
70
71 config KERNEL_PERF_EVENTS
72         bool "Compile the kernel with performance events and counters"
73         default n
74         select KERNEL_ARM_PMU if (arm || aarch64)
75
76 config KERNEL_PROFILING
77         bool "Compile the kernel with profiling enabled"
78         default n
79         select KERNEL_PERF_EVENTS
80         help
81           Enable the extended profiling support mechanisms used by profilers such
82           as OProfile.
83
84 config KERNEL_UBSAN
85         bool "Compile the kernel with undefined behaviour sanity checker"
86         help
87           This option enables undefined behaviour sanity checker
88           Compile-time instrumentation is used to detect various undefined
89           behaviours in runtime. Various types of checks may be enabled
90           via boot parameter ubsan_handle
91           (see: Documentation/dev-tools/ubsan.rst).
92
93 config KERNEL_UBSAN_SANITIZE_ALL
94         bool "Enable instrumentation for the entire kernel"
95         depends on KERNEL_UBSAN
96         default y
97         help
98           This option activates instrumentation for the entire kernel.
99           If you don't enable this option, you have to explicitly specify
100           UBSAN_SANITIZE := y for the files/directories you want to check for UB.
101           Enabling this option will get kernel image size increased
102           significantly.
103
104 config KERNEL_UBSAN_ALIGNMENT
105         bool "Enable checking of pointers alignment"
106         depends on KERNEL_UBSAN
107         help
108           This option enables detection of unaligned memory accesses.
109           Enabling this option on architectures that support unaligned
110           accesses may produce a lot of false positives.
111
112 config KERNEL_UBSAN_BOUNDS
113         bool "Perform array index bounds checking"
114         depends on KERNEL_UBSAN
115         help
116           This option enables detection of directly indexed out of bounds array
117           accesses, where the array size is known at compile time. Note that
118           this does not protect array overflows via bad calls to the
119           {str,mem}*cpy() family of functions (that is addressed by
120           FORTIFY_SOURCE).
121
122 config KERNEL_UBSAN_NULL
123         bool "Enable checking of null pointers"
124         depends on KERNEL_UBSAN
125         help
126           This option enables detection of memory accesses via a
127           null pointer.
128
129 config KERNEL_UBSAN_TRAP
130         bool "On Sanitizer warnings, abort the running kernel code"
131         depends on KERNEL_UBSAN
132         help
133           Building kernels with Sanitizer features enabled tends to grow the
134           kernel size by around 5%, due to adding all the debugging text on
135           failure paths. To avoid this, Sanitizer instrumentation can just
136           issue a trap. This reduces the kernel size overhead but turns all
137           warnings (including potentially harmless conditions) into full
138           exceptions that abort the running kernel code (regardless of context,
139           locks held, etc), which may destabilize the system. For some system
140           builders this is an acceptable trade-off.
141
142 config KERNEL_KASAN
143         bool "Compile the kernel with KASan: runtime memory debugger"
144         select KERNEL_SLUB_DEBUG
145         depends on (x86_64 || aarch64)
146         help
147           Enables kernel address sanitizer - runtime memory debugger,
148           designed to find out-of-bounds accesses and use-after-free bugs.
149           This is strictly a debugging feature and it requires a gcc version
150           of 4.9.2 or later. Detection of out of bounds accesses to stack or
151           global variables requires gcc 5.0 or later.
152           This feature consumes about 1/8 of available memory and brings about
153           ~x3 performance slowdown.
154           For better error detection enable CONFIG_STACKTRACE.
155           Currently CONFIG_KASAN doesn't work with CONFIG_DEBUG_SLAB
156           (the resulting kernel does not boot).
157
158 config KERNEL_KASAN_EXTRA
159         bool "KAsan: extra checks"
160         depends on KERNEL_KASAN && KERNEL_DEBUG_KERNEL
161         help
162           This enables further checks in the kernel address sanitizer, for now
163           it only includes the address-use-after-scope check that can lead
164           to excessive kernel stack usage, frame size warnings and longer
165           compile time.
166           https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81715 has more
167
168 config KERNEL_KASAN_VMALLOC
169         bool "Back mappings in vmalloc space with real shadow memory"
170         depends on KERNEL_KASAN
171         help
172           By default, the shadow region for vmalloc space is the read-only
173           zero page. This means that KASAN cannot detect errors involving
174           vmalloc space.
175
176           Enabling this option will hook in to vmap/vmalloc and back those
177           mappings with real shadow memory allocated on demand. This allows
178           for KASAN to detect more sorts of errors (and to support vmapped
179           stacks), but at the cost of higher memory usage.
180
181           This option depends on HAVE_ARCH_KASAN_VMALLOC, but we can't
182           depend on that in here, so it is possible that enabling this
183           will have no effect.
184
185 if KERNEL_KASAN
186         config KERNEL_KASAN_GENERIC
187         def_bool y
188
189         config KERNEL_KASAN_SW_TAGS
190         def_bool n
191 endif
192
193 choice
194         prompt "Instrumentation type"
195         depends on KERNEL_KASAN
196         default KERNEL_KASAN_OUTLINE
197
198 config KERNEL_KASAN_OUTLINE
199         bool "Outline instrumentation"
200         help
201           Before every memory access compiler insert function call
202           __asan_load*/__asan_store*. These functions performs check
203           of shadow memory. This is slower than inline instrumentation,
204           however it doesn't bloat size of kernel's .text section so
205           much as inline does.
206
207 config KERNEL_KASAN_INLINE
208         bool "Inline instrumentation"
209         help
210           Compiler directly inserts code checking shadow memory before
211           memory accesses. This is faster than outline (in some workloads
212           it gives about x2 boost over outline instrumentation), but
213           make kernel's .text size much bigger.
214           This requires a gcc version of 5.0 or later.
215
216 endchoice
217
218 config KERNEL_KCOV
219         bool "Compile the kernel with code coverage for fuzzing"
220         select KERNEL_DEBUG_FS
221         help
222           KCOV exposes kernel code coverage information in a form suitable
223           for coverage-guided fuzzing (randomized testing).
224
225           If RANDOMIZE_BASE is enabled, PC values will not be stable across
226           different machines and across reboots. If you need stable PC values,
227           disable RANDOMIZE_BASE.
228
229           For more details, see Documentation/kcov.txt.
230
231 config KERNEL_KCOV_ENABLE_COMPARISONS
232         bool "Enable comparison operands collection by KCOV"
233         depends on KERNEL_KCOV
234         help
235           KCOV also exposes operands of every comparison in the instrumented
236           code along with operand sizes and PCs of the comparison instructions.
237           These operands can be used by fuzzing engines to improve the quality
238           of fuzzing coverage.
239
240 config KERNEL_KCOV_INSTRUMENT_ALL
241         bool "Instrument all code by default"
242         depends on KERNEL_KCOV
243         default y if KERNEL_KCOV
244         help
245           If you are doing generic system call fuzzing (like e.g. syzkaller),
246           then you will want to instrument the whole kernel and you should
247           say y here. If you are doing more targeted fuzzing (like e.g.
248           filesystem fuzzing with AFL) then you will want to enable coverage
249           for more specific subsets of files, and should say n here.
250
251 config KERNEL_TASKSTATS
252         bool "Compile the kernel with task resource/io statistics and accounting"
253         default n
254         help
255           Enable the collection and publishing of task/io statistics and
256           accounting.  Enable this option to enable i/o monitoring in system
257           monitors.
258
259 if KERNEL_TASKSTATS
260
261         config KERNEL_TASK_DELAY_ACCT
262                 def_bool y
263
264         config KERNEL_TASK_IO_ACCOUNTING
265                 def_bool y
266
267         config KERNEL_TASK_XACCT
268                 def_bool y
269
270 endif
271
272 config KERNEL_KALLSYMS
273         bool "Compile the kernel with symbol table information"
274         default y if !SMALL_FLASH
275         help
276           This will give you more information in stack traces from kernel oopses.
277
278 config KERNEL_FTRACE
279         bool "Compile the kernel with tracing support"
280         depends on !TARGET_uml
281         default n
282
283 config KERNEL_FTRACE_SYSCALLS
284         bool "Trace system calls"
285         depends on KERNEL_FTRACE
286         default n
287
288 config KERNEL_ENABLE_DEFAULT_TRACERS
289         bool "Trace process context switches and events"
290         depends on KERNEL_FTRACE
291         default n
292
293 config KERNEL_FUNCTION_TRACER
294         bool "Function tracer"
295         depends on KERNEL_FTRACE
296         default n
297
298 config KERNEL_FUNCTION_GRAPH_TRACER
299         bool "Function graph tracer"
300         depends on KERNEL_FUNCTION_TRACER
301         default n
302
303 config KERNEL_DYNAMIC_FTRACE
304         bool "Enable/disable function tracing dynamically"
305         depends on KERNEL_FUNCTION_TRACER
306         default n
307
308 config KERNEL_FUNCTION_PROFILER
309         bool "Function profiler"
310         depends on KERNEL_FUNCTION_TRACER
311         default n
312
313 config KERNEL_IRQSOFF_TRACER
314         bool "Interrupts-off Latency Tracer"
315         depends on KERNEL_FTRACE
316         help
317           This option measures the time spent in irqs-off critical
318           sections, with microsecond accuracy.
319
320           The default measurement method is a maximum search, which is
321           disabled by default and can be runtime (re-)started
322           via:
323
324               echo 0 > /sys/kernel/debug/tracing/tracing_max_latency
325
326           (Note that kernel size and overhead increase with this option
327           enabled. This option and the preempt-off timing option can be
328           used together or separately.)
329
330 config KERNEL_PREEMPT_TRACER
331         bool "Preemption-off Latency Tracer"
332         depends on KERNEL_FTRACE
333         help
334           This option measures the time spent in preemption-off critical
335           sections, with microsecond accuracy.
336
337           The default measurement method is a maximum search, which is
338           disabled by default and can be runtime (re-)started
339           via:
340
341               echo 0 > /sys/kernel/debug/tracing/tracing_max_latency
342
343           (Note that kernel size and overhead increase with this option
344           enabled. This option and the irqs-off timing option can be
345           used together or separately.)
346
347 config KERNEL_HIST_TRIGGERS
348         bool "Histogram triggers"
349         depends on KERNEL_FTRACE
350         help
351           Hist triggers allow one or more arbitrary trace event fields to be
352           aggregated into hash tables and dumped to stdout by reading a
353           debugfs/tracefs file. They're useful for gathering quick and dirty
354           (though precise) summaries of event activity as an initial guide for
355           further investigation using more advanced tools.
356
357           Inter-event tracing of quantities such as latencies is also
358           supported using hist triggers under this option.
359
360 config KERNEL_DEBUG_KERNEL
361         bool
362         default n
363
364 config KERNEL_DEBUG_INFO
365         bool "Compile the kernel with debug information"
366         default y if !SMALL_FLASH
367         select KERNEL_DEBUG_KERNEL
368         help
369           This will compile your kernel and modules with debug information.
370
371 config KERNEL_DEBUG_LL_UART_NONE
372         bool
373         default n
374         depends on arm
375
376 config KERNEL_DEBUG_LL
377         bool
378         default n
379         depends on arm
380         select KERNEL_DEBUG_LL_UART_NONE
381         help
382           ARM low level debugging.
383
384 config KERNEL_DYNAMIC_DEBUG
385         bool "Compile the kernel with dynamic printk"
386         select KERNEL_DEBUG_FS
387         default n
388         help
389           Compiles debug level messages into the kernel, which would not
390           otherwise be available at runtime. These messages can then be
391           enabled/disabled based on various levels of scope - per source file,
392           function, module, format string, and line number. This mechanism
393           implicitly compiles in all pr_debug() and dev_dbg() calls, which
394           enlarges the kernel text size by about 2%.
395
396 config KERNEL_EARLY_PRINTK
397         bool "Compile the kernel with early printk"
398         default y if TARGET_bcm53xx
399         default n
400         depends on arm
401         select KERNEL_DEBUG_KERNEL
402         select KERNEL_DEBUG_LL if arm
403         help
404           Compile the kernel with early printk support.  This is only useful for
405           debugging purposes to send messages over the serial console in early boot.
406           Enable this to debug early boot problems.
407
408 config KERNEL_KPROBES
409         bool "Compile the kernel with kprobes support"
410         default n
411         select KERNEL_FTRACE
412         select KERNEL_PERF_EVENTS
413         help
414           Compiles the kernel with KPROBES support, which allows you to trap
415           at almost any kernel address and execute a callback function.
416           register_kprobe() establishes a probepoint and specifies the
417           callback. Kprobes is useful for kernel debugging, non-intrusive
418           instrumentation and testing.
419           If in doubt, say "N".
420
421 config KERNEL_KPROBE_EVENTS
422         bool
423         default y if KERNEL_KPROBES
424
425 config KERNEL_BPF_KPROBE_OVERRIDE
426         bool
427         depends on KERNEL_KPROBES
428         default n
429
430 config KERNEL_AIO
431         bool "Compile the kernel with asynchronous IO support"
432         default y if !SMALL_FLASH
433
434 config KERNEL_IO_URING
435         bool "Compile the kernel with io_uring support"
436         default y if !SMALL_FLASH
437
438 config KERNEL_FHANDLE
439         bool "Compile the kernel with support for fhandle syscalls"
440         default y if !SMALL_FLASH
441
442 config KERNEL_FANOTIFY
443         bool "Compile the kernel with modern file notification support"
444         default y if !SMALL_FLASH
445
446 config KERNEL_BLK_DEV_BSG
447         bool "Compile the kernel with SCSI generic v4 support for any block device"
448         default n
449
450 config KERNEL_TRANSPARENT_HUGEPAGE
451         bool
452
453 choice
454         prompt "Transparent Hugepage Support sysfs defaults"
455         depends on KERNEL_TRANSPARENT_HUGEPAGE
456         default KERNEL_TRANSPARENT_HUGEPAGE_ALWAYS
457
458         config KERNEL_TRANSPARENT_HUGEPAGE_ALWAYS
459                 bool "always"
460
461         config KERNEL_TRANSPARENT_HUGEPAGE_MADVISE
462                 bool "madvise"
463 endchoice
464
465 config KERNEL_HUGETLBFS
466         bool
467
468 config KERNEL_HUGETLB_PAGE
469         bool "Compile the kernel with HugeTLB support"
470         select KERNEL_TRANSPARENT_HUGEPAGE
471         select KERNEL_HUGETLBFS
472         default n
473
474 config KERNEL_MAGIC_SYSRQ
475         bool "Compile the kernel with SysRq support"
476         default y
477
478 config KERNEL_DEBUG_PINCTRL
479         bool "Compile the kernel with pinctrl debugging"
480         select KERNEL_DEBUG_KERNEL
481
482 config KERNEL_DEBUG_GPIO
483         bool "Compile the kernel with gpio debugging"
484         select KERNEL_DEBUG_KERNEL
485
486 config KERNEL_COREDUMP
487         bool
488
489 config KERNEL_ELF_CORE
490         bool "Enable process core dump support"
491         select KERNEL_COREDUMP
492         default y if !SMALL_FLASH
493
494 config KERNEL_PROVE_LOCKING
495         bool "Enable kernel lock checking"
496         select KERNEL_DEBUG_KERNEL
497         default n
498
499 config KERNEL_SOFTLOCKUP_DETECTOR
500         bool "Compile the kernel with detect Soft Lockups"
501         depends on KERNEL_DEBUG_KERNEL
502         help
503           Say Y here to enable the kernel to act as a watchdog to detect
504           soft lockups.
505
506           Softlockups are bugs that cause the kernel to loop in kernel
507           mode for more than 20 seconds, without giving other tasks a
508           chance to run.  The current stack trace is displayed upon
509           detection and the system will stay locked up.
510
511 config KERNEL_DETECT_HUNG_TASK
512         bool "Compile the kernel with detect Hung Tasks"
513         depends on KERNEL_DEBUG_KERNEL
514         default KERNEL_SOFTLOCKUP_DETECTOR
515         help
516           Say Y here to enable the kernel to detect "hung tasks",
517           which are bugs that cause the task to be stuck in
518           uninterruptible "D" state indefinitely.
519
520           When a hung task is detected, the kernel will print the
521           current stack trace (which you should report), but the
522           task will stay in uninterruptible state. If lockdep is
523           enabled then all held locks will also be reported. This
524           feature has negligible overhead.
525
526 config KERNEL_WQ_WATCHDOG
527         bool "Compile the kernel with detect Workqueue Stalls"
528         depends on KERNEL_DEBUG_KERNEL
529         help
530           Say Y here to enable stall detection on workqueues.  If a
531           worker pool doesn't make forward progress on a pending work
532           item for over a given amount of time, 30s by default, a
533           warning message is printed along with dump of workqueue
534           state.  This can be configured through kernel parameter
535           "workqueue.watchdog_thresh" and its sysfs counterpart.
536
537 config KERNEL_DEBUG_ATOMIC_SLEEP
538         bool "Compile the kernel with sleep inside atomic section checking"
539         depends on KERNEL_DEBUG_KERNEL
540         help
541           If you say Y here, various routines which may sleep will become very
542           noisy if they are called inside atomic sections: when a spinlock is
543           held, inside an rcu read side critical section, inside preempt disabled
544           sections, inside an interrupt, etc...
545
546 config KERNEL_DEBUG_VM
547         bool "Compile the kernel with debug VM"
548         depends on KERNEL_DEBUG_KERNEL
549         help
550           Enable this to turn on extended checks in the virtual-memory system
551           that may impact performance.
552
553           If unsure, say N.
554
555 config KERNEL_PRINTK_TIME
556         bool "Enable printk timestamps"
557         default y
558
559 config KERNEL_SLUB_DEBUG
560         bool
561
562 config KERNEL_SLUB_DEBUG_ON
563         bool
564
565 config KERNEL_SLABINFO
566         select KERNEL_SLUB_DEBUG
567         select KERNEL_SLUB_DEBUG_ON
568         bool "Enable /proc slab debug info"
569
570 config KERNEL_PROC_PAGE_MONITOR
571         bool "Enable /proc page monitoring"
572
573 config KERNEL_RELAY
574         bool
575
576 config KERNEL_KEXEC
577         bool "Enable kexec support"
578
579 config KERNEL_PROC_VMCORE
580         bool
581
582 config KERNEL_PROC_KCORE
583         bool
584
585 config KERNEL_CRASH_DUMP
586         depends on i386 || x86_64 || arm || armeb
587         select KERNEL_KEXEC
588         select KERNEL_PROC_VMCORE
589         select KERNEL_PROC_KCORE
590         bool "Enable support for kexec crashdump"
591         default y
592
593 config USE_RFKILL
594         bool "Enable rfkill support"
595         default RFKILL_SUPPORT
596
597 config USE_SPARSE
598         bool "Enable sparse check during kernel build"
599         default n
600
601 config KERNEL_DEVTMPFS
602         bool "Compile the kernel with device tmpfs enabled"
603         default n
604         help
605           devtmpfs is a simple, kernel-managed /dev filesystem. The kernel creates
606           devices nodes for all registered devices to simplify boot, but leaves more
607           complex tasks to userspace (e.g. udev).
608
609 if KERNEL_DEVTMPFS
610
611         config KERNEL_DEVTMPFS_MOUNT
612                 bool "Automatically mount devtmpfs after root filesystem is mounted"
613                 default n
614
615 endif
616
617 config KERNEL_KEYS
618         bool "Enable kernel access key retention support"
619         default !SMALL_FLASH
620
621 config KERNEL_PERSISTENT_KEYRINGS
622         bool "Enable kernel persistent keyrings"
623         depends on KERNEL_KEYS
624         default n
625
626 config KERNEL_KEYS_REQUEST_CACHE
627         bool "Enable temporary caching of the last request_key() result"
628         depends on KERNEL_KEYS
629         default n
630
631 config KERNEL_BIG_KEYS
632         bool "Enable large payload keys on kernel keyrings"
633         depends on KERNEL_KEYS
634         default n
635
636 #
637 # CGROUP support symbols
638 #
639
640 config KERNEL_CGROUPS
641         bool "Enable kernel cgroups"
642         default y if !SMALL_FLASH
643
644 if KERNEL_CGROUPS
645
646         config KERNEL_CGROUP_DEBUG
647                 bool "Example debug cgroup subsystem"
648                 default n
649                 help
650                   This option enables a simple cgroup subsystem that
651                   exports useful debugging information about the cgroups
652                   framework.
653
654         config KERNEL_FREEZER
655                 bool
656
657         config KERNEL_CGROUP_FREEZER
658                 bool "legacy Freezer cgroup subsystem"
659                 default n
660                 select KERNEL_FREEZER
661                 help
662                   Provides a way to freeze and unfreeze all tasks in a
663                   cgroup.
664                   (legacy cgroup1-only controller, in cgroup2 freezer
665                   is integrated in the Memory controller)
666
667         config KERNEL_CGROUP_DEVICE
668                 bool "legacy Device controller for cgroups"
669                 default n
670                 help
671                   Provides a cgroup implementing whitelists for devices which
672                   a process in the cgroup can mknod or open.
673                   (legacy cgroup1-only controller)
674
675         config KERNEL_CGROUP_HUGETLB
676                 bool "HugeTLB controller"
677                 default n
678                 select KERNEL_HUGETLB_PAGE
679
680         config KERNEL_CGROUP_PIDS
681                 bool "PIDs cgroup subsystem"
682                 default y
683                 help
684                   Provides enforcement of process number limits in the scope of a
685                   cgroup.
686
687         config KERNEL_CGROUP_RDMA
688                 bool "RDMA controller for cgroups"
689                 default y
690
691         config KERNEL_CGROUP_BPF
692                 bool "Support for eBPF programs attached to cgroups"
693                 default y
694
695         config KERNEL_CPUSETS
696                 bool "Cpuset support"
697                 default y
698                 help
699                   This option will let you create and manage CPUSETs which
700                   allow dynamically partitioning a system into sets of CPUs and
701                   Memory Nodes and assigning tasks to run only within those sets.
702                   This is primarily useful on large SMP or NUMA systems.
703
704         config KERNEL_PROC_PID_CPUSET
705                 bool "Include legacy /proc/<pid>/cpuset file"
706                 default n
707                 depends on KERNEL_CPUSETS
708
709         config KERNEL_CGROUP_CPUACCT
710                 bool "Simple CPU accounting cgroup subsystem"
711                 default y
712                 help
713                   Provides a simple Resource Controller for monitoring the
714                   total CPU consumed by the tasks in a cgroup.
715
716         config KERNEL_RESOURCE_COUNTERS
717                 bool "Resource counters"
718                 default y
719                 help
720                   This option enables controller independent resource accounting
721                   infrastructure that works with cgroups.
722
723         config KERNEL_MM_OWNER
724                 bool
725                 default y if KERNEL_MEMCG
726
727         config KERNEL_MEMCG
728                 bool "Memory Resource Controller for Control Groups"
729                 default y
730                 select KERNEL_FREEZER
731                 depends on KERNEL_RESOURCE_COUNTERS || !LINUX_3_18
732                 help
733                   Provides a memory resource controller that manages both anonymous
734                   memory and page cache. (See Documentation/cgroups/memory.txt)
735
736                   Note that setting this option increases fixed memory overhead
737                   associated with each page of memory in the system. By this,
738                   20(40)bytes/PAGE_SIZE on 32(64)bit system will be occupied by memory
739                   usage tracking struct at boot. Total amount of this is printed out
740                   at boot.
741
742                   Only enable when you're ok with these tradeoffs and really
743                   sure you need the memory resource controller. Even when you enable
744                   this, you can set "cgroup_disable=memory" at your boot option to
745                   disable memory resource controller and you can avoid overheads
746                   (but lose benefits of memory resource controller).
747
748                   This config option also selects MM_OWNER config option, which
749                   could in turn add some fork/exit overhead.
750
751         config KERNEL_MEMCG_SWAP
752                 bool "Memory Resource Controller Swap Extension"
753                 default y
754                 depends on KERNEL_MEMCG
755                 help
756                   Add swap management feature to memory resource controller. When you
757                   enable this, you can limit mem+swap usage per cgroup. In other words,
758                   when you disable this, memory resource controller has no cares to
759                   usage of swap...a process can exhaust all of the swap. This extension
760                   is useful when you want to avoid exhaustion swap but this itself
761                   adds more overheads and consumes memory for remembering information.
762                   Especially if you use 32bit system or small memory system, please
763                   be careful about enabling this. When memory resource controller
764                   is disabled by boot option, this will be automatically disabled and
765                   there will be no overhead from this. Even when you set this config=y,
766                   if boot option "swapaccount=0" is set, swap will not be accounted.
767                   Now, memory usage of swap_cgroup is 2 bytes per entry. If swap page
768                   size is 4096bytes, 512k per 1Gbytes of swap.
769
770         config KERNEL_MEMCG_SWAP_ENABLED
771                 bool "Memory Resource Controller Swap Extension enabled by default"
772                 default n
773                 depends on KERNEL_MEMCG_SWAP
774                 help
775                   Memory Resource Controller Swap Extension comes with its price in
776                   a bigger memory consumption. General purpose distribution kernels
777                   which want to enable the feature but keep it disabled by default
778                   and let the user enable it by swapaccount boot command line
779                   parameter should have this option unselected.
780
781                   Those who want to have the feature enabled by default should
782                   select this option (if, for some reason, they need to disable it,
783                   then swapaccount=0 does the trick).
784
785
786         config KERNEL_MEMCG_KMEM
787                 bool "Memory Resource Controller Kernel Memory accounting (EXPERIMENTAL)"
788                 default y
789                 depends on KERNEL_MEMCG
790                 help
791                   The Kernel Memory extension for Memory Resource Controller can limit
792                   the amount of memory used by kernel objects in the system. Those are
793                   fundamentally different from the entities handled by the standard
794                   Memory Controller, which are page-based, and can be swapped. Users of
795                   the kmem extension can use it to guarantee that no group of processes
796                   will ever exhaust kernel resources alone.
797
798         config KERNEL_CGROUP_PERF
799                 bool "Enable perf_event per-cpu per-container group (cgroup) monitoring"
800                 select KERNEL_PERF_EVENTS
801                 default n
802                 help
803                   This option extends the per-cpu mode to restrict monitoring to
804                   threads which belong to the cgroup specified and run on the
805                   designated cpu.
806
807         menuconfig KERNEL_CGROUP_SCHED
808                 bool "Group CPU scheduler"
809                 default y
810                 help
811                   This feature lets CPU scheduler recognize task groups and control CPU
812                   bandwidth allocation to such task groups. It uses cgroups to group
813                   tasks.
814
815         if KERNEL_CGROUP_SCHED
816
817                 config KERNEL_FAIR_GROUP_SCHED
818                         bool "Group scheduling for SCHED_OTHER"
819                         default y
820
821                 config KERNEL_CFS_BANDWIDTH
822                         bool "CPU bandwidth provisioning for FAIR_GROUP_SCHED"
823                         default y
824                         depends on KERNEL_FAIR_GROUP_SCHED
825                         help
826                           This option allows users to define CPU bandwidth rates (limits) for
827                           tasks running within the fair group scheduler.  Groups with no limit
828                           set are considered to be unconstrained and will run with no
829                           restriction.
830                           See tip/Documentation/scheduler/sched-bwc.txt for more information.
831
832                 config KERNEL_RT_GROUP_SCHED
833                         bool "Group scheduling for SCHED_RR/FIFO"
834                         default y
835                         help
836                           This feature lets you explicitly allocate real CPU bandwidth
837                           to task groups. If enabled, it will also make it impossible to
838                           schedule realtime tasks for non-root users until you allocate
839                           realtime bandwidth for them.
840
841         endif
842
843         config KERNEL_BLK_CGROUP
844                 bool "Block IO controller"
845                 default y
846                 help
847                   Generic block IO controller cgroup interface. This is the common
848                   cgroup interface which should be used by various IO controlling
849                   policies.
850
851                   Currently, CFQ IO scheduler uses it to recognize task groups and
852                   control disk bandwidth allocation (proportional time slice allocation)
853                   to such task groups. It is also used by bio throttling logic in
854                   block layer to implement upper limit in IO rates on a device.
855
856                   This option only enables generic Block IO controller infrastructure.
857                   One needs to also enable actual IO controlling logic/policy. For
858                   enabling proportional weight division of disk bandwidth in CFQ, set
859                   CONFIG_CFQ_GROUP_IOSCHED=y; for enabling throttling policy, set
860                   CONFIG_BLK_DEV_THROTTLING=y.
861
862         if KERNEL_BLK_CGROUP
863
864                 config KERNEL_CFQ_GROUP_IOSCHED
865                         bool "Proportional weight of disk bandwidth in CFQ"
866
867                 config KERNEL_BLK_DEV_THROTTLING
868                         bool "Enable throttling policy"
869                         default y
870
871                 config KERNEL_BLK_DEV_THROTTLING_LOW
872                         bool "Block throttling .low limit interface support (EXPERIMENTAL)"
873                         depends on KERNEL_BLK_DEV_THROTTLING
874         endif
875
876         config KERNEL_DEBUG_BLK_CGROUP
877                 bool "Enable Block IO controller debugging"
878                 default n
879                 depends on KERNEL_BLK_CGROUP
880                 help
881                   Enable some debugging help. Currently it exports additional stat
882                   files in a cgroup which can be useful for debugging.
883
884         config KERNEL_NET_CLS_CGROUP
885                 bool "legacy Control Group Classifier"
886                 default n
887
888         config KERNEL_CGROUP_NET_CLASSID
889                 bool "legacy Network classid cgroup"
890                 default n
891
892         config KERNEL_CGROUP_NET_PRIO
893                 bool "legacy Network priority cgroup"
894                 default n
895
896 endif
897
898 #
899 # Namespace support symbols
900 #
901
902 config KERNEL_NAMESPACES
903         bool "Enable kernel namespaces"
904         default y if !SMALL_FLASH
905
906 if KERNEL_NAMESPACES
907
908         config KERNEL_UTS_NS
909                 bool "UTS namespace"
910                 default y
911                 help
912                   In this namespace, tasks see different info provided
913                   with the uname() system call.
914
915         config KERNEL_IPC_NS
916                 bool "IPC namespace"
917                 default y
918                 help
919                   In this namespace, tasks work with IPC ids which correspond to
920                   different IPC objects in different namespaces.
921
922         config KERNEL_USER_NS
923                 bool "User namespace (EXPERIMENTAL)"
924                 default y
925                 help
926                   This allows containers, i.e. vservers, to use user namespaces
927                   to provide different user info for different servers.
928
929         config KERNEL_PID_NS
930                 bool "PID Namespaces"
931                 default y
932                 help
933                   Support process id namespaces. This allows having multiple
934                   processes with the same pid as long as they are in different
935                   pid namespaces. This is a building block of containers.
936
937         config KERNEL_NET_NS
938                 bool "Network namespace"
939                 default y
940                 help
941                   Allow user space to create what appear to be multiple instances
942                   of the network stack.
943
944 endif
945
946 config KERNEL_DEVPTS_MULTIPLE_INSTANCES
947         bool "Support multiple instances of devpts"
948         default y if !SMALL_FLASH
949         help
950           Enable support for multiple instances of devpts filesystem.
951           If you want to have isolated PTY namespaces (eg: in containers),
952           say Y here. Otherwise, say N. If enabled, each mount of devpts
953           filesystem with the '-o newinstance' option will create an
954           independent PTY namespace.
955
956 config KERNEL_POSIX_MQUEUE
957         bool "POSIX Message Queues"
958         default y if !SMALL_FLASH
959         help
960           POSIX variant of message queues is a part of IPC. In POSIX message
961           queues every message has a priority which decides about succession
962           of receiving it by a process. If you want to compile and run
963           programs written e.g. for Solaris with use of its POSIX message
964           queues (functions mq_*) say Y here.
965
966           POSIX message queues are visible as a filesystem called 'mqueue'
967           and can be mounted somewhere if you want to do filesystem
968           operations on message queues.
969
970
971 config KERNEL_SECCOMP_FILTER
972         bool
973         default y if !SMALL_FLASH
974
975 config KERNEL_SECCOMP
976         bool "Enable seccomp support"
977                 depends on !(TARGET_uml)
978                 select KERNEL_SECCOMP_FILTER
979                 default y if !SMALL_FLASH
980                 help
981                   Build kernel with support for seccomp.
982
983 #
984 # IPv4 configuration
985 #
986
987 config KERNEL_IP_MROUTE
988         bool "Enable IPv4 multicast routing"
989         default y
990         help
991           Multicast routing requires a multicast routing daemon in
992           addition to kernel support.
993
994 if KERNEL_IP_MROUTE
995
996         config KERNEL_IP_MROUTE_MULTIPLE_TABLES
997                 def_bool y
998
999         config KERNEL_IP_PIMSM_V1
1000                 def_bool y
1001
1002         config KERNEL_IP_PIMSM_V2
1003                 def_bool y
1004
1005 endif
1006
1007 #
1008 # IPv6 configuration
1009 #
1010
1011 config KERNEL_IPV6
1012         def_bool IPV6
1013
1014 if KERNEL_IPV6
1015
1016         config KERNEL_IPV6_MULTIPLE_TABLES
1017                 def_bool y
1018
1019         config KERNEL_IPV6_SUBTREES
1020                 def_bool y
1021
1022         config KERNEL_IPV6_MROUTE
1023                 bool "Enable IPv6 multicast routing"
1024                 default y
1025                 help
1026                   Multicast routing requires a multicast routing daemon in
1027                   addition to kernel support.
1028
1029         if KERNEL_IPV6_MROUTE
1030
1031                 config KERNEL_IPV6_MROUTE_MULTIPLE_TABLES
1032                         def_bool y
1033
1034                 config KERNEL_IPV6_PIMSM_V2
1035                         def_bool y
1036
1037         endif
1038
1039         config KERNEL_IPV6_SEG6_LWTUNNEL
1040                 bool "Enable support for lightweight tunnels"
1041                 default y if !SMALL_FLASH
1042                 help
1043                   Using lwtunnel (needed for IPv6 segment routing) requires ip-full package.
1044
1045         config KERNEL_LWTUNNEL_BPF
1046                 def_bool n
1047
1048 endif
1049
1050 #
1051 # Miscellaneous network configuration
1052 #
1053
1054 config KERNEL_NET_L3_MASTER_DEV
1055         bool "L3 Master device support"
1056         help
1057           This module provides glue between core networking code and device
1058           drivers to support L3 master devices like VRF.
1059
1060 #
1061 # NFS related symbols
1062 #
1063 config KERNEL_IP_PNP
1064         bool "Compile the kernel with rootfs on NFS"
1065         help
1066            If you want to make your kernel boot off a NFS server as root
1067            filesystem, select Y here.
1068
1069 if KERNEL_IP_PNP
1070
1071         config KERNEL_IP_PNP_DHCP
1072                 def_bool y
1073
1074         config KERNEL_IP_PNP_BOOTP
1075                 def_bool n
1076
1077         config KERNEL_IP_PNP_RARP
1078                 def_bool n
1079
1080         config KERNEL_NFS_FS
1081                 def_bool y
1082
1083         config KERNEL_NFS_V2
1084                 def_bool y
1085
1086         config KERNEL_NFS_V3
1087                 def_bool y
1088
1089         config KERNEL_ROOT_NFS
1090                 def_bool y
1091
1092 endif
1093
1094 menu "Filesystem ACL and attr support options"
1095         config USE_FS_ACL_ATTR
1096                 bool "Use filesystem ACL and attr support by default"
1097                 default n
1098                 help
1099                   Make using ACLs (e.g. POSIX ACL, NFSv4 ACL) the default
1100                   for kernel and packages, except tmpfs, flash filesystems,
1101                   and old NFS.  Also enable userspace extended attribute support
1102                   by default.  (OpenWrt already has an expection it will be
1103                   present in the kernel).
1104
1105         config KERNEL_FS_POSIX_ACL
1106                 bool "Enable POSIX ACL support"
1107                 default y if USE_FS_ACL_ATTR
1108
1109         config KERNEL_BTRFS_FS_POSIX_ACL
1110                 bool "Enable POSIX ACL for BtrFS Filesystems"
1111                 select KERNEL_FS_POSIX_ACL
1112                 default y if USE_FS_ACL_ATTR
1113
1114         config KERNEL_EXT4_FS_POSIX_ACL
1115                 bool "Enable POSIX ACL for Ext4 Filesystems"
1116                 select KERNEL_FS_POSIX_ACL
1117                 default y if USE_FS_ACL_ATTR
1118
1119         config KERNEL_F2FS_FS_POSIX_ACL
1120                 bool "Enable POSIX ACL for F2FS Filesystems"
1121                 select KERNEL_FS_POSIX_ACL
1122                 default n
1123
1124         config KERNEL_JFFS2_FS_POSIX_ACL
1125                 bool "Enable POSIX ACL for JFFS2 Filesystems"
1126                 select KERNEL_FS_POSIX_ACL
1127                 default n
1128
1129         config KERNEL_TMPFS_POSIX_ACL
1130                 bool "Enable POSIX ACL for TMPFS Filesystems"
1131                 select KERNEL_FS_POSIX_ACL
1132                 default n
1133
1134         config KERNEL_CIFS_ACL
1135                 bool "Enable CIFS ACLs"
1136                 select KERNEL_FS_POSIX_ACL
1137                 default y if USE_FS_ACL_ATTR
1138
1139         config KERNEL_HFS_FS_POSIX_ACL
1140                 bool "Enable POSIX ACL for HFS Filesystems"
1141                 select KERNEL_FS_POSIX_ACL
1142                 default y if USE_FS_ACL_ATTR
1143
1144         config KERNEL_HFSPLUS_FS_POSIX_ACL
1145                 bool "Enable POSIX ACL for HFS+ Filesystems"
1146                 select KERNEL_FS_POSIX_ACL
1147                 default y if USE_FS_ACL_ATTR
1148
1149         config KERNEL_NFS_ACL_SUPPORT
1150                 bool "Enable ACLs for NFS"
1151                 default y if USE_FS_ACL_ATTR
1152
1153         config KERNEL_NFS_V3_ACL_SUPPORT
1154                 bool "Enable ACLs for NFSv3"
1155                 default n
1156
1157         config KERNEL_NFSD_V2_ACL_SUPPORT
1158                 bool "Enable ACLs for NFSDv2"
1159                 default n
1160
1161         config KERNEL_NFSD_V3_ACL_SUPPORT
1162                 bool "Enable ACLs for NFSDv3"
1163                 default n
1164
1165         config KERNEL_REISER_FS_POSIX_ACL
1166                 bool "Enable POSIX ACLs for ReiserFS"
1167                 select KERNEL_FS_POSIX_ACL
1168                 default y if USE_FS_ACL_ATTR
1169
1170         config KERNEL_XFS_POSIX_ACL
1171                 bool "Enable POSIX ACLs for XFS"
1172                 select KERNEL_FS_POSIX_ACL
1173                 default y if USE_FS_ACL_ATTR
1174
1175         config KERNEL_JFS_POSIX_ACL
1176                 bool "Enable POSIX ACLs for JFS"
1177                 select KERNEL_FS_POSIX_ACL
1178                 default y if USE_FS_ACL_ATTR
1179
1180 endmenu
1181
1182 config KERNEL_DEVMEM
1183         bool "/dev/mem virtual device support"
1184         help
1185           Say Y here if you want to support the /dev/mem device.
1186           The /dev/mem device is used to access areas of physical
1187           memory.
1188
1189 config KERNEL_DEVKMEM
1190         bool "/dev/kmem virtual device support"
1191         help
1192           Say Y here if you want to support the /dev/kmem device. The
1193           /dev/kmem device is rarely used, but can be used for certain
1194           kind of kernel debugging operations.
1195
1196 config KERNEL_SQUASHFS_FRAGMENT_CACHE_SIZE
1197         int "Number of squashfs fragments cached"
1198         default 2 if (SMALL_FLASH && !LOW_MEMORY_FOOTPRINT)
1199         default 3
1200
1201 config KERNEL_SQUASHFS_XATTR
1202         bool "Squashfs XATTR support"
1203
1204 #
1205 # compile optimization setting
1206 #
1207 choice
1208         prompt "Compiler optimization level"
1209         default KERNEL_CC_OPTIMIZE_FOR_SIZE if SMALL_FLASH
1210
1211 config KERNEL_CC_OPTIMIZE_FOR_PERFORMANCE
1212         bool "Optimize for performance"
1213         help
1214           This is the default optimization level for the kernel, building
1215           with the "-O2" compiler flag for best performance and most
1216           helpful compile-time warnings.
1217
1218 config KERNEL_CC_OPTIMIZE_FOR_SIZE
1219         bool "Optimize for size"
1220         help
1221           Enabling this option will pass "-Os" instead of "-O2" to
1222           your compiler resulting in a smaller kernel.
1223
1224 endchoice
1225
1226 config KERNEL_AUDIT
1227         bool "Auditing support"
1228
1229 config KERNEL_SECURITY
1230         bool "Enable different security models"
1231
1232 config KERNEL_SECURITY_NETWORK
1233         bool "Socket and Networking Security Hooks"
1234         select KERNEL_SECURITY
1235
1236 config KERNEL_SECURITY_SELINUX
1237         bool "NSA SELinux Support"
1238         select KERNEL_SECURITY_NETWORK
1239         select KERNEL_AUDIT
1240
1241 config KERNEL_SECURITY_SELINUX_BOOTPARAM
1242         bool "NSA SELinux boot parameter"
1243         depends on KERNEL_SECURITY_SELINUX
1244         default y
1245
1246 config KERNEL_SECURITY_SELINUX_DISABLE
1247         bool "NSA SELinux runtime disable"
1248         depends on KERNEL_SECURITY_SELINUX
1249
1250 config KERNEL_SECURITY_SELINUX_DEVELOP
1251         bool "NSA SELinux Development Support"
1252         depends on KERNEL_SECURITY_SELINUX
1253         default y
1254
1255 config KERNEL_SECURITY_SELINUX_SIDTAB_HASH_BITS
1256         int
1257         depends on KERNEL_SECURITY_SELINUX
1258         default 9
1259
1260 config KERNEL_SECURITY_SELINUX_SID2STR_CACHE_SIZE
1261         int
1262         depends on KERNEL_SECURITY_SELINUX
1263         default 256
1264
1265 config KERNEL_LSM
1266         string
1267         default "lockdown,yama,loadpin,safesetid,integrity,selinux"
1268         depends on KERNEL_SECURITY_SELINUX
1269
1270 config KERNEL_EXT4_FS_SECURITY
1271         bool "Ext4 Security Labels"
1272
1273 config KERNEL_F2FS_FS_SECURITY
1274         bool "F2FS Security Labels"
1275
1276 config KERNEL_UBIFS_FS_SECURITY
1277         bool "UBIFS Security Labels"
1278
1279 config KERNEL_JFFS2_FS_SECURITY
1280         bool "JFFS2 Security Labels"