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