config/Config-kernel.in

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