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