OSDN Git Service

kernel: add missing symbol for bcm27xx
[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
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_LL_UART_NONE
377         bool
378         default n
379         depends on arm
380
381 config KERNEL_DEBUG_LL
382         bool
383         default n
384         depends on arm
385         select KERNEL_DEBUG_LL_UART_NONE
386         help
387           ARM low level debugging.
388
389 config KERNEL_DYNAMIC_DEBUG
390         bool "Compile the kernel with dynamic printk"
391         select KERNEL_DEBUG_FS
392         default n
393         help
394           Compiles debug level messages into the kernel, which would not
395           otherwise be available at runtime. These messages can then be
396           enabled/disabled based on various levels of scope - per source file,
397           function, module, format string, and line number. This mechanism
398           implicitly compiles in all pr_debug() and dev_dbg() calls, which
399           enlarges the kernel text size by about 2%.
400
401 config KERNEL_EARLY_PRINTK
402         bool "Compile the kernel with early printk"
403         default y if TARGET_bcm53xx
404         default n
405         depends on arm
406         select KERNEL_DEBUG_KERNEL
407         select KERNEL_DEBUG_LL if arm
408         help
409           Compile the kernel with early printk support.  This is only useful for
410           debugging purposes to send messages over the serial console in early boot.
411           Enable this to debug early boot problems.
412
413 config KERNEL_KPROBES
414         bool "Compile the kernel with kprobes support"
415         default n
416         select KERNEL_FTRACE
417         select KERNEL_PERF_EVENTS
418         help
419           Compiles the kernel with KPROBES support, which allows you to trap
420           at almost any kernel address and execute a callback function.
421           register_kprobe() establishes a probepoint and specifies the
422           callback. Kprobes is useful for kernel debugging, non-intrusive
423           instrumentation and testing.
424           If in doubt, say "N".
425
426 config KERNEL_KPROBE_EVENTS
427         bool
428         default y if KERNEL_KPROBES
429
430 config KERNEL_BPF_KPROBE_OVERRIDE
431         bool
432         depends on KERNEL_KPROBES
433         default n
434
435 config KERNEL_AIO
436         bool "Compile the kernel with asynchronous IO support"
437         default y if !SMALL_FLASH
438
439 config KERNEL_IO_URING
440         bool "Compile the kernel with io_uring support"
441         default y if !SMALL_FLASH
442
443 config KERNEL_FHANDLE
444         bool "Compile the kernel with support for fhandle syscalls"
445         default y if !SMALL_FLASH
446
447 config KERNEL_FANOTIFY
448         bool "Compile the kernel with modern file notification support"
449         default y if !SMALL_FLASH
450
451 config KERNEL_BLK_DEV_BSG
452         bool "Compile the kernel with SCSI generic v4 support for any block device"
453         default n
454
455 config KERNEL_TRANSPARENT_HUGEPAGE
456         bool
457
458 choice
459         prompt "Transparent Hugepage Support sysfs defaults"
460         depends on KERNEL_TRANSPARENT_HUGEPAGE
461         default KERNEL_TRANSPARENT_HUGEPAGE_ALWAYS
462
463         config KERNEL_TRANSPARENT_HUGEPAGE_ALWAYS
464                 bool "always"
465
466         config KERNEL_TRANSPARENT_HUGEPAGE_MADVISE
467                 bool "madvise"
468 endchoice
469
470 config KERNEL_HUGETLBFS
471         bool
472
473 config KERNEL_HUGETLB_PAGE
474         bool "Compile the kernel with HugeTLB support"
475         select KERNEL_TRANSPARENT_HUGEPAGE
476         select KERNEL_HUGETLBFS
477         default n
478
479 config KERNEL_MAGIC_SYSRQ
480         bool "Compile the kernel with SysRq support"
481         default y
482
483 config KERNEL_DEBUG_PINCTRL
484         bool "Compile the kernel with pinctrl debugging"
485         select KERNEL_DEBUG_KERNEL
486
487 config KERNEL_DEBUG_GPIO
488         bool "Compile the kernel with gpio debugging"
489         select KERNEL_DEBUG_KERNEL
490
491 config KERNEL_COREDUMP
492         bool
493
494 config KERNEL_ELF_CORE
495         bool "Enable process core dump support"
496         select KERNEL_COREDUMP
497         default y if !SMALL_FLASH
498
499 config KERNEL_PROVE_LOCKING
500         bool "Enable kernel lock checking"
501         select KERNEL_DEBUG_KERNEL
502         default n
503
504 config KERNEL_SOFTLOCKUP_DETECTOR
505         bool "Compile the kernel with detect Soft Lockups"
506         depends on KERNEL_DEBUG_KERNEL
507         help
508           Say Y here to enable the kernel to act as a watchdog to detect
509           soft lockups.
510
511           Softlockups are bugs that cause the kernel to loop in kernel
512           mode for more than 20 seconds, without giving other tasks a
513           chance to run.  The current stack trace is displayed upon
514           detection and the system will stay locked up.
515
516 config KERNEL_DETECT_HUNG_TASK
517         bool "Compile the kernel with detect Hung Tasks"
518         depends on KERNEL_DEBUG_KERNEL
519         default KERNEL_SOFTLOCKUP_DETECTOR
520         help
521           Say Y here to enable the kernel to detect "hung tasks",
522           which are bugs that cause the task to be stuck in
523           uninterruptible "D" state indefinitely.
524
525           When a hung task is detected, the kernel will print the
526           current stack trace (which you should report), but the
527           task will stay in uninterruptible state. If lockdep is
528           enabled then all held locks will also be reported. This
529           feature has negligible overhead.
530
531 config KERNEL_WQ_WATCHDOG
532         bool "Compile the kernel with detect Workqueue Stalls"
533         depends on KERNEL_DEBUG_KERNEL
534         help
535           Say Y here to enable stall detection on workqueues.  If a
536           worker pool doesn't make forward progress on a pending work
537           item for over a given amount of time, 30s by default, a
538           warning message is printed along with dump of workqueue
539           state.  This can be configured through kernel parameter
540           "workqueue.watchdog_thresh" and its sysfs counterpart.
541
542 config KERNEL_DEBUG_ATOMIC_SLEEP
543         bool "Compile the kernel with sleep inside atomic section checking"
544         depends on KERNEL_DEBUG_KERNEL
545         help
546           If you say Y here, various routines which may sleep will become very
547           noisy if they are called inside atomic sections: when a spinlock is
548           held, inside an rcu read side critical section, inside preempt disabled
549           sections, inside an interrupt, etc...
550
551 config KERNEL_DEBUG_VM
552         bool "Compile the kernel with debug VM"
553         depends on KERNEL_DEBUG_KERNEL
554         help
555           Enable this to turn on extended checks in the virtual-memory system
556           that may impact performance.
557
558           If unsure, say N.
559
560 config KERNEL_PRINTK_TIME
561         bool "Enable printk timestamps"
562         default y
563
564 config KERNEL_SLUB_DEBUG
565         bool
566
567 config KERNEL_SLUB_DEBUG_ON
568         bool
569
570 config KERNEL_SLABINFO
571         select KERNEL_SLUB_DEBUG
572         select KERNEL_SLUB_DEBUG_ON
573         bool "Enable /proc slab debug info"
574
575 config KERNEL_PROC_PAGE_MONITOR
576         bool "Enable /proc page monitoring"
577
578 config KERNEL_RELAY
579         bool
580
581 config KERNEL_KEXEC
582         bool "Enable kexec support"
583
584 config KERNEL_PROC_VMCORE
585         bool
586
587 config KERNEL_PROC_KCORE
588         bool
589
590 config KERNEL_CRASH_DUMP
591         depends on i386 || x86_64 || arm || armeb
592         select KERNEL_KEXEC
593         select KERNEL_PROC_VMCORE
594         select KERNEL_PROC_KCORE
595         bool "Enable support for kexec crashdump"
596         default y
597
598 config USE_RFKILL
599         bool "Enable rfkill support"
600         default RFKILL_SUPPORT
601
602 config USE_SPARSE
603         bool "Enable sparse check during kernel build"
604         default n
605
606 config KERNEL_DEVTMPFS
607         bool "Compile the kernel with device tmpfs enabled"
608         default n
609         help
610           devtmpfs is a simple, kernel-managed /dev filesystem. The kernel creates
611           devices nodes for all registered devices to simplify boot, but leaves more
612           complex tasks to userspace (e.g. udev).
613
614 if KERNEL_DEVTMPFS
615
616         config KERNEL_DEVTMPFS_MOUNT
617                 bool "Automatically mount devtmpfs after root filesystem is mounted"
618                 default n
619
620 endif
621
622 config KERNEL_KEYS
623         bool "Enable kernel access key retention support"
624         default !SMALL_FLASH
625
626 config KERNEL_PERSISTENT_KEYRINGS
627         bool "Enable kernel persistent keyrings"
628         depends on KERNEL_KEYS
629         default n
630
631 config KERNEL_KEYS_REQUEST_CACHE
632         bool "Enable temporary caching of the last request_key() result"
633         depends on KERNEL_KEYS
634         default n
635
636 config KERNEL_BIG_KEYS
637         bool "Enable large payload keys on kernel keyrings"
638         depends on KERNEL_KEYS
639         default n
640
641 #
642 # CGROUP support symbols
643 #
644
645 config KERNEL_CGROUPS
646         bool "Enable kernel cgroups"
647         default y if !SMALL_FLASH
648
649 if KERNEL_CGROUPS
650
651         config KERNEL_CGROUP_DEBUG
652                 bool "Example debug cgroup subsystem"
653                 default n
654                 help
655                   This option enables a simple cgroup subsystem that
656                   exports useful debugging information about the cgroups
657                   framework.
658
659         config KERNEL_FREEZER
660                 bool
661
662         config KERNEL_CGROUP_FREEZER
663                 bool "legacy Freezer cgroup subsystem"
664                 default n
665                 select KERNEL_FREEZER
666                 help
667                   Provides a way to freeze and unfreeze all tasks in a
668                   cgroup.
669                   (legacy cgroup1-only controller, in cgroup2 freezer
670                   is integrated in the Memory controller)
671
672         config KERNEL_CGROUP_DEVICE
673                 bool "legacy Device controller for cgroups"
674                 default n
675                 help
676                   Provides a cgroup implementing whitelists for devices which
677                   a process in the cgroup can mknod or open.
678                   (legacy cgroup1-only controller)
679
680         config KERNEL_CGROUP_HUGETLB
681                 bool "HugeTLB controller"
682                 default n
683                 select KERNEL_HUGETLB_PAGE
684
685         config KERNEL_CGROUP_PIDS
686                 bool "PIDs cgroup subsystem"
687                 default y
688                 help
689                   Provides enforcement of process number limits in the scope of a
690                   cgroup.
691
692         config KERNEL_CGROUP_RDMA
693                 bool "RDMA controller for cgroups"
694                 default y
695
696         config KERNEL_CGROUP_BPF
697                 bool "Support for eBPF programs attached to cgroups"
698                 default y
699
700         config KERNEL_CPUSETS
701                 bool "Cpuset support"
702                 default y
703                 help
704                   This option will let you create and manage CPUSETs which
705                   allow dynamically partitioning a system into sets of CPUs and
706                   Memory Nodes and assigning tasks to run only within those sets.
707                   This is primarily useful on large SMP or NUMA systems.
708
709         config KERNEL_PROC_PID_CPUSET
710                 bool "Include legacy /proc/<pid>/cpuset file"
711                 default n
712                 depends on KERNEL_CPUSETS
713
714         config KERNEL_CGROUP_CPUACCT
715                 bool "Simple CPU accounting cgroup subsystem"
716                 default y
717                 help
718                   Provides a simple Resource Controller for monitoring the
719                   total CPU consumed by the tasks in a cgroup.
720
721         config KERNEL_RESOURCE_COUNTERS
722                 bool "Resource counters"
723                 default y
724                 help
725                   This option enables controller independent resource accounting
726                   infrastructure that works with cgroups.
727
728         config KERNEL_MM_OWNER
729                 bool
730                 default y if KERNEL_MEMCG
731
732         config KERNEL_MEMCG
733                 bool "Memory Resource Controller for Control Groups"
734                 default y
735                 select KERNEL_FREEZER
736                 depends on KERNEL_RESOURCE_COUNTERS || !LINUX_3_18
737                 help
738                   Provides a memory resource controller that manages both anonymous
739                   memory and page cache. (See Documentation/cgroups/memory.txt)
740
741                   Note that setting this option increases fixed memory overhead
742                   associated with each page of memory in the system. By this,
743                   20(40)bytes/PAGE_SIZE on 32(64)bit system will be occupied by memory
744                   usage tracking struct at boot. Total amount of this is printed out
745                   at boot.
746
747                   Only enable when you're ok with these tradeoffs and really
748                   sure you need the memory resource controller. Even when you enable
749                   this, you can set "cgroup_disable=memory" at your boot option to
750                   disable memory resource controller and you can avoid overheads
751                   (but lose benefits of memory resource controller).
752
753                   This config option also selects MM_OWNER config option, which
754                   could in turn add some fork/exit overhead.
755
756         config KERNEL_MEMCG_SWAP
757                 bool "Memory Resource Controller Swap Extension"
758                 default y
759                 depends on KERNEL_MEMCG
760                 help
761                   Add swap management feature to memory resource controller. When you
762                   enable this, you can limit mem+swap usage per cgroup. In other words,
763                   when you disable this, memory resource controller has no cares to
764                   usage of swap...a process can exhaust all of the swap. This extension
765                   is useful when you want to avoid exhaustion swap but this itself
766                   adds more overheads and consumes memory for remembering information.
767                   Especially if you use 32bit system or small memory system, please
768                   be careful about enabling this. When memory resource controller
769                   is disabled by boot option, this will be automatically disabled and
770                   there will be no overhead from this. Even when you set this config=y,
771                   if boot option "swapaccount=0" is set, swap will not be accounted.
772                   Now, memory usage of swap_cgroup is 2 bytes per entry. If swap page
773                   size is 4096bytes, 512k per 1Gbytes of swap.
774
775         config KERNEL_MEMCG_SWAP_ENABLED
776                 bool "Memory Resource Controller Swap Extension enabled by default"
777                 default n
778                 depends on KERNEL_MEMCG_SWAP
779                 help
780                   Memory Resource Controller Swap Extension comes with its price in
781                   a bigger memory consumption. General purpose distribution kernels
782                   which want to enable the feature but keep it disabled by default
783                   and let the user enable it by swapaccount boot command line
784                   parameter should have this option unselected.
785
786                   Those who want to have the feature enabled by default should
787                   select this option (if, for some reason, they need to disable it,
788                   then swapaccount=0 does the trick).
789
790
791         config KERNEL_MEMCG_KMEM
792                 bool "Memory Resource Controller Kernel Memory accounting (EXPERIMENTAL)"
793                 default y
794                 depends on KERNEL_MEMCG
795                 help
796                   The Kernel Memory extension for Memory Resource Controller can limit
797                   the amount of memory used by kernel objects in the system. Those are
798                   fundamentally different from the entities handled by the standard
799                   Memory Controller, which are page-based, and can be swapped. Users of
800                   the kmem extension can use it to guarantee that no group of processes
801                   will ever exhaust kernel resources alone.
802
803         config KERNEL_CGROUP_PERF
804                 bool "Enable perf_event per-cpu per-container group (cgroup) monitoring"
805                 select KERNEL_PERF_EVENTS
806                 default n
807                 help
808                   This option extends the per-cpu mode to restrict monitoring to
809                   threads which belong to the cgroup specified and run on the
810                   designated cpu.
811
812         menuconfig KERNEL_CGROUP_SCHED
813                 bool "Group CPU scheduler"
814                 default y
815                 help
816                   This feature lets CPU scheduler recognize task groups and control CPU
817                   bandwidth allocation to such task groups. It uses cgroups to group
818                   tasks.
819
820         if KERNEL_CGROUP_SCHED
821
822                 config KERNEL_FAIR_GROUP_SCHED
823                         bool "Group scheduling for SCHED_OTHER"
824                         default y
825
826                 config KERNEL_CFS_BANDWIDTH
827                         bool "CPU bandwidth provisioning for FAIR_GROUP_SCHED"
828                         default y
829                         depends on KERNEL_FAIR_GROUP_SCHED
830                         help
831                           This option allows users to define CPU bandwidth rates (limits) for
832                           tasks running within the fair group scheduler.  Groups with no limit
833                           set are considered to be unconstrained and will run with no
834                           restriction.
835                           See tip/Documentation/scheduler/sched-bwc.txt for more information.
836
837                 config KERNEL_RT_GROUP_SCHED
838                         bool "Group scheduling for SCHED_RR/FIFO"
839                         default y
840                         help
841                           This feature lets you explicitly allocate real CPU bandwidth
842                           to task groups. If enabled, it will also make it impossible to
843                           schedule realtime tasks for non-root users until you allocate
844                           realtime bandwidth for them.
845
846         endif
847
848         config KERNEL_BLK_CGROUP
849                 bool "Block IO controller"
850                 default y
851                 help
852                   Generic block IO controller cgroup interface. This is the common
853                   cgroup interface which should be used by various IO controlling
854                   policies.
855
856                   Currently, CFQ IO scheduler uses it to recognize task groups and
857                   control disk bandwidth allocation (proportional time slice allocation)
858                   to such task groups. It is also used by bio throttling logic in
859                   block layer to implement upper limit in IO rates on a device.
860
861                   This option only enables generic Block IO controller infrastructure.
862                   One needs to also enable actual IO controlling logic/policy. For
863                   enabling proportional weight division of disk bandwidth in CFQ, set
864                   CONFIG_CFQ_GROUP_IOSCHED=y; for enabling throttling policy, set
865                   CONFIG_BLK_DEV_THROTTLING=y.
866
867         if KERNEL_BLK_CGROUP
868
869                 config KERNEL_CFQ_GROUP_IOSCHED
870                         bool "Proportional weight of disk bandwidth in CFQ"
871
872                 config KERNEL_BLK_DEV_THROTTLING
873                         bool "Enable throttling policy"
874                         default y
875
876                 config KERNEL_BLK_DEV_THROTTLING_LOW
877                         bool "Block throttling .low limit interface support (EXPERIMENTAL)"
878                         depends on KERNEL_BLK_DEV_THROTTLING
879         endif
880
881         config KERNEL_DEBUG_BLK_CGROUP
882                 bool "Enable Block IO controller debugging"
883                 default n
884                 depends on KERNEL_BLK_CGROUP
885                 help
886                   Enable some debugging help. Currently it exports additional stat
887                   files in a cgroup which can be useful for debugging.
888
889         config KERNEL_NET_CLS_CGROUP
890                 bool "legacy Control Group Classifier"
891                 default n
892
893         config KERNEL_CGROUP_NET_CLASSID
894                 bool "legacy Network classid cgroup"
895                 default n
896
897         config KERNEL_CGROUP_NET_PRIO
898                 bool "legacy Network priority cgroup"
899                 default n
900
901 endif
902
903 #
904 # Namespace support symbols
905 #
906
907 config KERNEL_NAMESPACES
908         bool "Enable kernel namespaces"
909         default y if !SMALL_FLASH
910
911 if KERNEL_NAMESPACES
912
913         config KERNEL_UTS_NS
914                 bool "UTS namespace"
915                 default y
916                 help
917                   In this namespace, tasks see different info provided
918                   with the uname() system call.
919
920         config KERNEL_IPC_NS
921                 bool "IPC namespace"
922                 default y
923                 help
924                   In this namespace, tasks work with IPC ids which correspond to
925                   different IPC objects in different namespaces.
926
927         config KERNEL_USER_NS
928                 bool "User namespace (EXPERIMENTAL)"
929                 default y
930                 help
931                   This allows containers, i.e. vservers, to use user namespaces
932                   to provide different user info for different servers.
933
934         config KERNEL_PID_NS
935                 bool "PID Namespaces"
936                 default y
937                 help
938                   Support process id namespaces. This allows having multiple
939                   processes with the same pid as long as they are in different
940                   pid namespaces. This is a building block of containers.
941
942         config KERNEL_NET_NS
943                 bool "Network namespace"
944                 default y
945                 help
946                   Allow user space to create what appear to be multiple instances
947                   of the network stack.
948
949 endif
950
951 config KERNEL_DEVPTS_MULTIPLE_INSTANCES
952         bool "Support multiple instances of devpts"
953         default y if !SMALL_FLASH
954         help
955           Enable support for multiple instances of devpts filesystem.
956           If you want to have isolated PTY namespaces (eg: in containers),
957           say Y here. Otherwise, say N. If enabled, each mount of devpts
958           filesystem with the '-o newinstance' option will create an
959           independent PTY namespace.
960
961 config KERNEL_POSIX_MQUEUE
962         bool "POSIX Message Queues"
963         default y if !SMALL_FLASH
964         help
965           POSIX variant of message queues is a part of IPC. In POSIX message
966           queues every message has a priority which decides about succession
967           of receiving it by a process. If you want to compile and run
968           programs written e.g. for Solaris with use of its POSIX message
969           queues (functions mq_*) say Y here.
970
971           POSIX message queues are visible as a filesystem called 'mqueue'
972           and can be mounted somewhere if you want to do filesystem
973           operations on message queues.
974
975
976 config KERNEL_SECCOMP_FILTER
977         bool
978         default y if !SMALL_FLASH
979
980 config KERNEL_SECCOMP
981         bool "Enable seccomp support"
982                 depends on !(TARGET_uml)
983                 select KERNEL_SECCOMP_FILTER
984                 default y if !SMALL_FLASH
985                 help
986                   Build kernel with support for seccomp.
987
988 #
989 # IPv4 configuration
990 #
991
992 config KERNEL_IP_MROUTE
993         bool "Enable IPv4 multicast routing"
994         default y
995         help
996           Multicast routing requires a multicast routing daemon in
997           addition to kernel support.
998
999 if KERNEL_IP_MROUTE
1000
1001         config KERNEL_IP_MROUTE_MULTIPLE_TABLES
1002                 def_bool y
1003
1004         config KERNEL_IP_PIMSM_V1
1005                 def_bool y
1006
1007         config KERNEL_IP_PIMSM_V2
1008                 def_bool y
1009
1010 endif
1011
1012 #
1013 # IPv6 configuration
1014 #
1015
1016 config KERNEL_IPV6
1017         def_bool IPV6
1018
1019 if KERNEL_IPV6
1020
1021         config KERNEL_IPV6_MULTIPLE_TABLES
1022                 def_bool y
1023
1024         config KERNEL_IPV6_SUBTREES
1025                 def_bool y
1026
1027         config KERNEL_IPV6_MROUTE
1028                 bool "Enable IPv6 multicast routing"
1029                 default y
1030                 help
1031                   Multicast routing requires a multicast routing daemon in
1032                   addition to kernel support.
1033
1034         if KERNEL_IPV6_MROUTE
1035
1036                 config KERNEL_IPV6_MROUTE_MULTIPLE_TABLES
1037                         def_bool y
1038
1039                 config KERNEL_IPV6_PIMSM_V2
1040                         def_bool y
1041
1042         endif
1043
1044         config KERNEL_IPV6_SEG6_LWTUNNEL
1045                 bool "Enable support for lightweight tunnels"
1046                 default y if !SMALL_FLASH
1047                 help
1048                   Using lwtunnel (needed for IPv6 segment routing) requires ip-full package.
1049
1050         config KERNEL_LWTUNNEL_BPF
1051                 def_bool n
1052
1053 endif
1054
1055 #
1056 # Miscellaneous network configuration
1057 #
1058
1059 config KERNEL_NET_L3_MASTER_DEV
1060         bool "L3 Master device support"
1061         help
1062           This module provides glue between core networking code and device
1063           drivers to support L3 master devices like VRF.
1064
1065 #
1066 # NFS related symbols
1067 #
1068 config KERNEL_IP_PNP
1069         bool "Compile the kernel with rootfs on NFS"
1070         help
1071            If you want to make your kernel boot off a NFS server as root
1072            filesystem, select Y here.
1073
1074 if KERNEL_IP_PNP
1075
1076         config KERNEL_IP_PNP_DHCP
1077                 def_bool y
1078
1079         config KERNEL_IP_PNP_BOOTP
1080                 def_bool n
1081
1082         config KERNEL_IP_PNP_RARP
1083                 def_bool n
1084
1085         config KERNEL_NFS_FS
1086                 def_bool y
1087
1088         config KERNEL_NFS_V2
1089                 def_bool y
1090
1091         config KERNEL_NFS_V3
1092                 def_bool y
1093
1094         config KERNEL_ROOT_NFS
1095                 def_bool y
1096
1097 endif
1098
1099 menu "Filesystem ACL and attr support options"
1100         config USE_FS_ACL_ATTR
1101                 bool "Use filesystem ACL and attr support by default"
1102                 default n
1103                 help
1104                   Make using ACLs (e.g. POSIX ACL, NFSv4 ACL) the default
1105                   for kernel and packages, except tmpfs, flash filesystems,
1106                   and old NFS.  Also enable userspace extended attribute support
1107                   by default.  (OpenWrt already has an expection it will be
1108                   present in the kernel).
1109
1110         config KERNEL_FS_POSIX_ACL
1111                 bool "Enable POSIX ACL support"
1112                 default y if USE_FS_ACL_ATTR
1113
1114         config KERNEL_BTRFS_FS_POSIX_ACL
1115                 bool "Enable POSIX ACL for BtrFS Filesystems"
1116                 select KERNEL_FS_POSIX_ACL
1117                 default y if USE_FS_ACL_ATTR
1118
1119         config KERNEL_EXT4_FS_POSIX_ACL
1120                 bool "Enable POSIX ACL for Ext4 Filesystems"
1121                 select KERNEL_FS_POSIX_ACL
1122                 default y if USE_FS_ACL_ATTR
1123
1124         config KERNEL_F2FS_FS_POSIX_ACL
1125                 bool "Enable POSIX ACL for F2FS Filesystems"
1126                 select KERNEL_FS_POSIX_ACL
1127                 default n
1128
1129         config KERNEL_JFFS2_FS_POSIX_ACL
1130                 bool "Enable POSIX ACL for JFFS2 Filesystems"
1131                 select KERNEL_FS_POSIX_ACL
1132                 default n
1133
1134         config KERNEL_TMPFS_POSIX_ACL
1135                 bool "Enable POSIX ACL for TMPFS Filesystems"
1136                 select KERNEL_FS_POSIX_ACL
1137                 default n
1138
1139         config KERNEL_CIFS_ACL
1140                 bool "Enable CIFS ACLs"
1141                 select KERNEL_FS_POSIX_ACL
1142                 default y if USE_FS_ACL_ATTR
1143
1144         config KERNEL_HFS_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_HFSPLUS_FS_POSIX_ACL
1150                 bool "Enable POSIX ACL for HFS+ Filesystems"
1151                 select KERNEL_FS_POSIX_ACL
1152                 default y if USE_FS_ACL_ATTR
1153
1154         config KERNEL_NFS_ACL_SUPPORT
1155                 bool "Enable ACLs for NFS"
1156                 default y if USE_FS_ACL_ATTR
1157
1158         config KERNEL_NFS_V3_ACL_SUPPORT
1159                 bool "Enable ACLs for NFSv3"
1160                 default n
1161
1162         config KERNEL_NFSD_V2_ACL_SUPPORT
1163                 bool "Enable ACLs for NFSDv2"
1164                 default n
1165
1166         config KERNEL_NFSD_V3_ACL_SUPPORT
1167                 bool "Enable ACLs for NFSDv3"
1168                 default n
1169
1170         config KERNEL_REISER_FS_POSIX_ACL
1171                 bool "Enable POSIX ACLs for ReiserFS"
1172                 select KERNEL_FS_POSIX_ACL
1173                 default y if USE_FS_ACL_ATTR
1174
1175         config KERNEL_XFS_POSIX_ACL
1176                 bool "Enable POSIX ACLs for XFS"
1177                 select KERNEL_FS_POSIX_ACL
1178                 default y if USE_FS_ACL_ATTR
1179
1180         config KERNEL_JFS_POSIX_ACL
1181                 bool "Enable POSIX ACLs for JFS"
1182                 select KERNEL_FS_POSIX_ACL
1183                 default y if USE_FS_ACL_ATTR
1184
1185 endmenu
1186
1187 config KERNEL_DEVMEM
1188         bool "/dev/mem virtual device support"
1189         help
1190           Say Y here if you want to support the /dev/mem device.
1191           The /dev/mem device is used to access areas of physical
1192           memory.
1193
1194 config KERNEL_DEVKMEM
1195         bool "/dev/kmem virtual device support"
1196         help
1197           Say Y here if you want to support the /dev/kmem device. The
1198           /dev/kmem device is rarely used, but can be used for certain
1199           kind of kernel debugging operations.
1200
1201 config KERNEL_SQUASHFS_FRAGMENT_CACHE_SIZE
1202         int "Number of squashfs fragments cached"
1203         default 2 if (SMALL_FLASH && !LOW_MEMORY_FOOTPRINT)
1204         default 3
1205
1206 config KERNEL_SQUASHFS_XATTR
1207         bool "Squashfs XATTR support"
1208
1209 #
1210 # compile optimization setting
1211 #
1212 choice
1213         prompt "Compiler optimization level"
1214         default KERNEL_CC_OPTIMIZE_FOR_SIZE if SMALL_FLASH
1215
1216 config KERNEL_CC_OPTIMIZE_FOR_PERFORMANCE
1217         bool "Optimize for performance"
1218         help
1219           This is the default optimization level for the kernel, building
1220           with the "-O2" compiler flag for best performance and most
1221           helpful compile-time warnings.
1222
1223 config KERNEL_CC_OPTIMIZE_FOR_SIZE
1224         bool "Optimize for size"
1225         help
1226           Enabling this option will pass "-Os" instead of "-O2" to
1227           your compiler resulting in a smaller kernel.
1228
1229 endchoice
1230
1231 config KERNEL_AUDIT
1232         bool "Auditing support"
1233
1234 config KERNEL_SECURITY
1235         bool "Enable different security models"
1236
1237 config KERNEL_SECURITY_NETWORK
1238         bool "Socket and Networking Security Hooks"
1239         select KERNEL_SECURITY
1240
1241 config KERNEL_SECURITY_SELINUX
1242         bool "NSA SELinux Support"
1243         select KERNEL_SECURITY_NETWORK
1244         select KERNEL_AUDIT
1245
1246 config KERNEL_SECURITY_SELINUX_BOOTPARAM
1247         bool "NSA SELinux boot parameter"
1248         depends on KERNEL_SECURITY_SELINUX
1249         default y
1250
1251 config KERNEL_SECURITY_SELINUX_DISABLE
1252         bool "NSA SELinux runtime disable"
1253         depends on KERNEL_SECURITY_SELINUX
1254
1255 config KERNEL_SECURITY_SELINUX_DEVELOP
1256         bool "NSA SELinux Development Support"
1257         depends on KERNEL_SECURITY_SELINUX
1258         default y
1259
1260 config KERNEL_SECURITY_SELINUX_SIDTAB_HASH_BITS
1261         int
1262         depends on KERNEL_SECURITY_SELINUX
1263         default 9
1264
1265 config KERNEL_SECURITY_SELINUX_SID2STR_CACHE_SIZE
1266         int
1267         depends on KERNEL_SECURITY_SELINUX
1268         default 256
1269
1270 config KERNEL_LSM
1271         string
1272         default "lockdown,yama,loadpin,safesetid,integrity,selinux"
1273         depends on KERNEL_SECURITY_SELINUX
1274
1275 config KERNEL_EXT4_FS_SECURITY
1276         bool "Ext4 Security Labels"
1277
1278 config KERNEL_F2FS_FS_SECURITY
1279         bool "F2FS Security Labels"
1280
1281 config KERNEL_UBIFS_FS_SECURITY
1282         bool "UBIFS Security Labels"
1283
1284 config KERNEL_JFFS2_FS_SECURITY
1285         bool "JFFS2 Security Labels"