OSDN Git Service

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