config/Config-kernel.in

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