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_MAGIC_SYSRQ
 361         bool "Compile the kernel with SysRq support"
 362         default y
 363
 364 config KERNEL_DEBUG_PINCTRL
 365         bool "Compile the kernel with pinctrl debugging"
 366         select KERNEL_DEBUG_KERNEL
 367
 368 config KERNEL_DEBUG_GPIO
 369         bool "Compile the kernel with gpio debugging"
 370         select KERNEL_DEBUG_KERNEL
 371
 372 config KERNEL_COREDUMP
 373         bool
 374
 375 config KERNEL_ELF_CORE
 376         bool "Enable process core dump support"
 377         select KERNEL_COREDUMP
 378         default y if !SMALL_FLASH
 379
 380 config KERNEL_PROVE_LOCKING
 381         bool "Enable kernel lock checking"
 382         select KERNEL_DEBUG_KERNEL
 383         default n
 384
 385 config KERNEL_LOCKUP_DETECTOR
 386         bool "Compile the kernel with detect Hard and Soft Lockups"
 387         depends on KERNEL_DEBUG_KERNEL
 388         help
 389           Say Y here to enable the kernel to act as a watchdog to detect
 390           hard and soft lockups.
 391
 392           Softlockups are bugs that cause the kernel to loop in kernel
 393           mode for more than 20 seconds, without giving other tasks a
 394           chance to run.  The current stack trace is displayed upon
 395           detection and the system will stay locked up.
 396
 397           Hardlockups are bugs that cause the CPU to loop in kernel mode
 398           for more than 10 seconds, without letting other interrupts have a
 399           chance to run.  The current stack trace is displayed upon detection
 400           and the system will stay locked up.
 401
 402           The overhead should be minimal.  A periodic hrtimer runs to
 403           generate interrupts and kick the watchdog task every 4 seconds.
 404           An NMI is generated every 10 seconds or so to check for hardlockups.
 405
 406           The frequency of hrtimer and NMI events and the soft and hard lockup
 407           thresholds can be controlled through the sysctl watchdog_thresh.
 408
 409 config KERNEL_DETECT_HUNG_TASK
 410         bool "Compile the kernel with detect Hung Tasks"
 411         depends on KERNEL_DEBUG_KERNEL
 412         default KERNEL_LOCKUP_DETECTOR
 413         help
 414           Say Y here to enable the kernel to detect "hung tasks",
 415           which are bugs that cause the task to be stuck in
 416           uninterruptible "D" state indefinitely.
 417
 418           When a hung task is detected, the kernel will print the
 419           current stack trace (which you should report), but the
 420           task will stay in uninterruptible state. If lockdep is
 421           enabled then all held locks will also be reported. This
 422           feature has negligible overhead.
 423
 424 config KERNEL_WQ_WATCHDOG
 425         bool "Compile the kernel with detect Workqueue Stalls"
 426         depends on KERNEL_DEBUG_KERNEL
 427         help
 428           Say Y here to enable stall detection on workqueues.  If a
 429           worker pool doesn't make forward progress on a pending work
 430           item for over a given amount of time, 30s by default, a
 431           warning message is printed along with dump of workqueue
 432           state.  This can be configured through kernel parameter
 433           "workqueue.watchdog_thresh" and its sysfs counterpart.
 434
 435 config KERNEL_DEBUG_ATOMIC_SLEEP
 436         bool "Compile the kernel with sleep inside atomic section checking"
 437         depends on KERNEL_DEBUG_KERNEL
 438         help
 439           If you say Y here, various routines which may sleep will become very
 440           noisy if they are called inside atomic sections: when a spinlock is
 441           held, inside an rcu read side critical section, inside preempt disabled
 442           sections, inside an interrupt, etc...
 443
 444 config KERNEL_DEBUG_VM
 445         bool "Compile the kernel with debug VM"
 446         depends on KERNEL_DEBUG_KERNEL
 447         help
 448           Enable this to turn on extended checks in the virtual-memory system
 449           that may impact performance.
 450
 451           If unsure, say N.
 452
 453 config KERNEL_PRINTK_TIME
 454         bool "Enable printk timestamps"
 455         default y
 456
 457 config KERNEL_SLUB_DEBUG
 458         bool
 459
 460 config KERNEL_SLUB_DEBUG_ON
 461         bool
 462
 463 config KERNEL_SLABINFO
 464         select KERNEL_SLUB_DEBUG
 465         select KERNEL_SLUB_DEBUG_ON
 466         bool "Enable /proc slab debug info"
 467
 468 config KERNEL_PROC_PAGE_MONITOR
 469         bool "Enable /proc page monitoring"
 470
 471 config KERNEL_RELAY
 472         bool
 473
 474 config KERNEL_KEXEC
 475         bool "Enable kexec support"
 476
 477 config KERNEL_PROC_VMCORE
 478         bool
 479
 480 config KERNEL_CRASH_DUMP
 481         depends on i386 || x86_64 || arm || armeb
 482         select KERNEL_KEXEC
 483         select KERNEL_PROC_VMCORE
 484         bool "Enable support for kexec crashdump"
 485         default y
 486
 487 config USE_RFKILL
 488         bool "Enable rfkill support"
 489         default RFKILL_SUPPORT
 490
 491 config USE_SPARSE
 492         bool "Enable sparse check during kernel build"
 493         default n
 494
 495 config KERNEL_DEVTMPFS
 496         bool "Compile the kernel with device tmpfs enabled"
 497         default n
 498         help
 499           devtmpfs is a simple, kernel-managed /dev filesystem. The kernel creates
 500           devices nodes for all registered devices to simplify boot, but leaves more
 501           complex tasks to userspace (e.g. udev).
 502
 503 if KERNEL_DEVTMPFS
 504
 505         config KERNEL_DEVTMPFS_MOUNT
 506                 bool "Automatically mount devtmpfs after root filesystem is mounted"
 507                 default n
 508
 509 endif
 510
 511 config KERNEL_KEYS
 512     bool "Enable kernel access key retention support"
 513     default n
 514
 515 config KERNEL_PERSISTENT_KEYRINGS
 516     bool "Enable kernel persistent keyrings"
 517     depends on KERNEL_KEYS
 518     default n
 519
 520 config KERNEL_BIG_KEYS
 521     bool "Enable large payload keys on kernel keyrings"
 522     depends on KERNEL_KEYS
 523     default n
 524
 525 config KERNEL_ENCRYPTED_KEYS
 526     tristate "Enable keys with encrypted payloads on kernel keyrings"
 527     depends on KERNEL_KEYS
 528     default n
 529
 530 #
 531 # CGROUP support symbols
 532 #
 533
 534 config KERNEL_CGROUPS
 535         bool "Enable kernel cgroups"
 536         default y if !SMALL_FLASH
 537
 538 if KERNEL_CGROUPS
 539
 540         config KERNEL_CGROUP_DEBUG
 541                 bool "Example debug cgroup subsystem"
 542                 default n
 543                 help
 544                   This option enables a simple cgroup subsystem that
 545                   exports useful debugging information about the cgroups
 546                   framework.
 547
 548         config KERNEL_FREEZER
 549                 bool
 550                 default y if KERNEL_CGROUP_FREEZER
 551
 552         config KERNEL_CGROUP_FREEZER
 553                 bool "Freezer cgroup subsystem"
 554                 default y
 555                 help
 556                   Provides a way to freeze and unfreeze all tasks in a
 557                   cgroup.
 558
 559         config KERNEL_CGROUP_DEVICE
 560                 bool "Device controller for cgroups"
 561                 default y
 562                 help
 563                   Provides a cgroup implementing whitelists for devices which
 564                   a process in the cgroup can mknod or open.
 565
 566         config KERNEL_CGROUP_PIDS
 567                 bool "PIDs cgroup subsystem"
 568                 default y
 569                 help
 570                   Provides enforcement of process number limits in the scope of a
 571                   cgroup.
 572
 573         config KERNEL_CPUSETS
 574                 bool "Cpuset support"
 575                 default y if !SMALL_FLASH
 576                 help
 577                   This option will let you create and manage CPUSETs which
 578                   allow dynamically partitioning a system into sets of CPUs and
 579                   Memory Nodes and assigning tasks to run only within those sets.
 580                   This is primarily useful on large SMP or NUMA systems.
 581
 582         config KERNEL_PROC_PID_CPUSET
 583                 bool "Include legacy /proc/<pid>/cpuset file"
 584                 default n
 585                 depends on KERNEL_CPUSETS
 586
 587         config KERNEL_CGROUP_CPUACCT
 588                 bool "Simple CPU accounting cgroup subsystem"
 589                 default y if !SMALL_FLASH
 590                 help
 591                   Provides a simple Resource Controller for monitoring the
 592                   total CPU consumed by the tasks in a cgroup.
 593
 594         config KERNEL_RESOURCE_COUNTERS
 595                 bool "Resource counters"
 596                 default y if !SMALL_FLASH
 597                 help
 598                   This option enables controller independent resource accounting
 599                   infrastructure that works with cgroups.
 600
 601         config KERNEL_MM_OWNER
 602                 bool
 603                 default y if KERNEL_MEMCG
 604
 605         config KERNEL_MEMCG
 606                 bool "Memory Resource Controller for Control Groups"
 607                 default y if !SMALL_FLASH
 608                 depends on KERNEL_RESOURCE_COUNTERS || !LINUX_3_18
 609                 help
 610                   Provides a memory resource controller that manages both anonymous
 611                   memory and page cache. (See Documentation/cgroups/memory.txt)
 612
 613                   Note that setting this option increases fixed memory overhead
 614                   associated with each page of memory in the system. By this,
 615                   20(40)bytes/PAGE_SIZE on 32(64)bit system will be occupied by memory
 616                   usage tracking struct at boot. Total amount of this is printed out
 617                   at boot.
 618
 619                   Only enable when you're ok with these tradeoffs and really
 620                   sure you need the memory resource controller. Even when you enable
 621                   this, you can set "cgroup_disable=memory" at your boot option to
 622                   disable memory resource controller and you can avoid overheads
 623                   (but lose benefits of memory resource controller).
 624
 625                   This config option also selects MM_OWNER config option, which
 626                   could in turn add some fork/exit overhead.
 627
 628         config KERNEL_MEMCG_SWAP
 629                 bool "Memory Resource Controller Swap Extension"
 630                 default n
 631                 depends on KERNEL_MEMCG
 632                 help
 633                   Add swap management feature to memory resource controller. When you
 634                   enable this, you can limit mem+swap usage per cgroup. In other words,
 635                   when you disable this, memory resource controller has no cares to
 636                   usage of swap...a process can exhaust all of the swap. This extension
 637                   is useful when you want to avoid exhaustion swap but this itself
 638                   adds more overheads and consumes memory for remembering information.
 639                   Especially if you use 32bit system or small memory system, please
 640                   be careful about enabling this. When memory resource controller
 641                   is disabled by boot option, this will be automatically disabled and
 642                   there will be no overhead from this. Even when you set this config=y,
 643                   if boot option "swapaccount=0" is set, swap will not be accounted.
 644                   Now, memory usage of swap_cgroup is 2 bytes per entry. If swap page
 645                   size is 4096bytes, 512k per 1Gbytes of swap.
 646
 647         config KERNEL_MEMCG_SWAP_ENABLED
 648                 bool "Memory Resource Controller Swap Extension enabled by default"
 649                 default n
 650                 depends on KERNEL_MEMCG_SWAP
 651                 help
 652                   Memory Resource Controller Swap Extension comes with its price in
 653                   a bigger memory consumption. General purpose distribution kernels
 654                   which want to enable the feature but keep it disabled by default
 655                   and let the user enable it by swapaccount boot command line
 656                   parameter should have this option unselected.
 657
 658                   Those who want to have the feature enabled by default should
 659                   select this option (if, for some reason, they need to disable it,
 660                   then swapaccount=0 does the trick).
 661
 662
 663         config KERNEL_MEMCG_KMEM
 664                 bool "Memory Resource Controller Kernel Memory accounting (EXPERIMENTAL)"
 665                 default y if !SMALL_FLASH
 666                 depends on KERNEL_MEMCG
 667                 help
 668                   The Kernel Memory extension for Memory Resource Controller can limit
 669                   the amount of memory used by kernel objects in the system. Those are
 670                   fundamentally different from the entities handled by the standard
 671                   Memory Controller, which are page-based, and can be swapped. Users of
 672                   the kmem extension can use it to guarantee that no group of processes
 673                   will ever exhaust kernel resources alone.
 674
 675         config KERNEL_CGROUP_PERF
 676                 bool "Enable perf_event per-cpu per-container group (cgroup) monitoring"
 677                 select KERNEL_PERF_EVENTS
 678                 default n
 679                 help
 680                   This option extends the per-cpu mode to restrict monitoring to
 681                   threads which belong to the cgroup specified and run on the
 682                   designated cpu.
 683
 684         menuconfig KERNEL_CGROUP_SCHED
 685                 bool "Group CPU scheduler"
 686                 default y if !SMALL_FLASH
 687                 help
 688                   This feature lets CPU scheduler recognize task groups and control CPU
 689                   bandwidth allocation to such task groups. It uses cgroups to group
 690                   tasks.
 691
 692         if KERNEL_CGROUP_SCHED
 693
 694                 config KERNEL_FAIR_GROUP_SCHED
 695                         bool "Group scheduling for SCHED_OTHER"
 696                         default y if !SMALL_FLASH
 697
 698                 config KERNEL_CFS_BANDWIDTH
 699                         bool "CPU bandwidth provisioning for FAIR_GROUP_SCHED"
 700                         default n
 701                         depends on KERNEL_FAIR_GROUP_SCHED
 702                         help
 703                           This option allows users to define CPU bandwidth rates (limits) for
 704                           tasks running within the fair group scheduler.  Groups with no limit
 705                           set are considered to be unconstrained and will run with no
 706                           restriction.
 707                           See tip/Documentation/scheduler/sched-bwc.txt for more information.
 708
 709                 config KERNEL_RT_GROUP_SCHED
 710                         bool "Group scheduling for SCHED_RR/FIFO"
 711                         default y if !SMALL_FLASH
 712                         help
 713                           This feature lets you explicitly allocate real CPU bandwidth
 714                           to task groups. If enabled, it will also make it impossible to
 715                           schedule realtime tasks for non-root users until you allocate
 716                           realtime bandwidth for them.
 717
 718         endif
 719
 720         config KERNEL_BLK_CGROUP
 721                 bool "Block IO controller"
 722                 default y
 723                 help
 724                   Generic block IO controller cgroup interface. This is the common
 725                   cgroup interface which should be used by various IO controlling
 726                   policies.
 727
 728                   Currently, CFQ IO scheduler uses it to recognize task groups and
 729                   control disk bandwidth allocation (proportional time slice allocation)
 730                   to such task groups. It is also used by bio throttling logic in
 731                   block layer to implement upper limit in IO rates on a device.
 732
 733                   This option only enables generic Block IO controller infrastructure.
 734                   One needs to also enable actual IO controlling logic/policy. For
 735                   enabling proportional weight division of disk bandwidth in CFQ, set
 736                   CONFIG_CFQ_GROUP_IOSCHED=y; for enabling throttling policy, set
 737                   CONFIG_BLK_DEV_THROTTLING=y.
 738
 739         if KERNEL_BLK_CGROUP
 740
 741                 config KERNEL_CFQ_GROUP_IOSCHED
 742                         bool "Proportional weight of disk bandwidth in CFQ"
 743
 744                 config KERNEL_BLK_DEV_THROTTLING
 745                         bool "Enable throttling policy"
 746                         default y if TARGET_bcm27xx
 747
 748                 config KERNEL_BLK_DEV_THROTTLING_LOW
 749                         bool "Block throttling .low limit interface support (EXPERIMENTAL)"
 750                         depends on KERNEL_BLK_DEV_THROTTLING
 751         endif
 752
 753         config KERNEL_DEBUG_BLK_CGROUP
 754                 bool "Enable Block IO controller debugging"
 755                 default n
 756                 depends on KERNEL_BLK_CGROUP
 757                 help
 758                   Enable some debugging help. Currently it exports additional stat
 759                   files in a cgroup which can be useful for debugging.
 760
 761         config KERNEL_NET_CLS_CGROUP
 762                 bool "Control Group Classifier"
 763                 default y
 764
 765         config KERNEL_NETPRIO_CGROUP
 766                 bool "Network priority cgroup"
 767                 default y
 768
 769 endif
 770
 771 #
 772 # Namespace support symbols
 773 #
 774
 775 config KERNEL_NAMESPACES
 776         bool "Enable kernel namespaces"
 777         default y if !SMALL_FLASH
 778
 779 if KERNEL_NAMESPACES
 780
 781         config KERNEL_UTS_NS
 782                 bool "UTS namespace"
 783                 default y
 784                 help
 785                   In this namespace, tasks see different info provided
 786                   with the uname() system call.
 787
 788         config KERNEL_IPC_NS
 789                 bool "IPC namespace"
 790                 default y
 791                 help
 792                   In this namespace, tasks work with IPC ids which correspond to
 793                   different IPC objects in different namespaces.
 794
 795         config KERNEL_USER_NS
 796                 bool "User namespace (EXPERIMENTAL)"
 797                 default y
 798                 help
 799                   This allows containers, i.e. vservers, to use user namespaces
 800                   to provide different user info for different servers.
 801
 802         config KERNEL_PID_NS
 803                 bool "PID Namespaces"
 804                 default y
 805                 help
 806                   Support process id namespaces. This allows having multiple
 807                   processes with the same pid as long as they are in different
 808                   pid namespaces. This is a building block of containers.
 809
 810         config KERNEL_NET_NS
 811                 bool "Network namespace"
 812                 default y
 813                 help
 814                   Allow user space to create what appear to be multiple instances
 815                   of the network stack.
 816
 817 endif
 818
 819 config KERNEL_DEVPTS_MULTIPLE_INSTANCES
 820         bool "Support multiple instances of devpts"
 821         default y if !SMALL_FLASH
 822         help
 823           Enable support for multiple instances of devpts filesystem.
 824           If you want to have isolated PTY namespaces (eg: in containers),
 825           say Y here. Otherwise, say N. If enabled, each mount of devpts
 826           filesystem with the '-o newinstance' option will create an
 827           independent PTY namespace.
 828
 829 config KERNEL_POSIX_MQUEUE
 830         bool "POSIX Message Queues"
 831         default y if !SMALL_FLASH
 832         help
 833           POSIX variant of message queues is a part of IPC. In POSIX message
 834           queues every message has a priority which decides about succession
 835           of receiving it by a process. If you want to compile and run
 836           programs written e.g. for Solaris with use of its POSIX message
 837           queues (functions mq_*) say Y here.
 838
 839           POSIX message queues are visible as a filesystem called 'mqueue'
 840           and can be mounted somewhere if you want to do filesystem
 841           operations on message queues.
 842
 843
 844 config KERNEL_SECCOMP_FILTER
 845         bool
 846         default y if !SMALL_FLASH
 847
 848 config KERNEL_SECCOMP
 849         bool "Enable seccomp support"
 850                 depends on !(TARGET_uml)
 851                 select KERNEL_SECCOMP_FILTER
 852                 default y if !SMALL_FLASH
 853                 help
 854                   Build kernel with support for seccomp.
 855
 856 #
 857 # IPv4 configuration
 858 #
 859
 860 config KERNEL_IP_MROUTE
 861         bool "Enable IPv4 multicast routing"
 862         default y
 863         help
 864           Multicast routing requires a multicast routing daemon in
 865           addition to kernel support.
 866
 867 #
 868 # IPv6 configuration
 869 #
 870
 871 config KERNEL_IPV6
 872         def_bool IPV6
 873
 874 if KERNEL_IPV6
 875
 876         config KERNEL_IPV6_MULTIPLE_TABLES
 877                 def_bool y
 878
 879         config KERNEL_IPV6_SUBTREES
 880                 def_bool y
 881
 882         config KERNEL_IPV6_MROUTE
 883                 bool "Enable IPv6 multicast routing"
 884                 default y
 885                 help
 886                   Multicast routing requires a multicast routing daemon in
 887                   addition to kernel support.
 888
 889         config KERNEL_IPV6_PIMSM_V2
 890                 def_bool n
 891
 892 endif
 893
 894 #
 895 # NFS related symbols
 896 #
 897 config KERNEL_IP_PNP
 898         bool "Compile the kernel with rootfs on NFS"
 899         help
 900            If you want to make your kernel boot off a NFS server as root
 901            filesystem, select Y here.
 902
 903 if KERNEL_IP_PNP
 904
 905         config KERNEL_IP_PNP_DHCP
 906                 def_bool y
 907
 908         config KERNEL_IP_PNP_BOOTP
 909                 def_bool n
 910
 911         config KERNEL_IP_PNP_RARP
 912                 def_bool n
 913
 914         config KERNEL_NFS_FS
 915                 def_bool y
 916
 917         config KERNEL_NFS_V2
 918                 def_bool y
 919
 920         config KERNEL_NFS_V3
 921                 def_bool y
 922
 923         config KERNEL_ROOT_NFS
 924                 def_bool y
 925
 926 endif
 927
 928 menu "Filesystem ACL and attr support options"
 929         config USE_FS_ACL_ATTR
 930                 bool "Use filesystem ACL and attr support by default"
 931                 default n
 932                 help
 933                   Make using ACLs (e.g. POSIX ACL, NFSv4 ACL) the default
 934                   for kernel and packages, except tmpfs, flash filesystems,
 935                   and old NFS.  Also enable userspace extended attribute support
 936                   by default.  (OpenWrt already has an expection it will be
 937                   present in the kernel).
 938
 939         config KERNEL_FS_POSIX_ACL
 940                 bool "Enable POSIX ACL support"
 941                 default y if USE_FS_ACL_ATTR
 942
 943         config KERNEL_BTRFS_FS_POSIX_ACL
 944                 bool "Enable POSIX ACL for BtrFS Filesystems"
 945                 select KERNEL_FS_POSIX_ACL
 946                 default y if USE_FS_ACL_ATTR
 947
 948         config KERNEL_EXT4_FS_POSIX_ACL
 949                 bool "Enable POSIX ACL for Ext4 Filesystems"
 950                 select KERNEL_FS_POSIX_ACL
 951                 default y if USE_FS_ACL_ATTR
 952
 953         config KERNEL_F2FS_FS_POSIX_ACL
 954                 bool "Enable POSIX ACL for F2FS Filesystems"
 955                 select KERNEL_FS_POSIX_ACL
 956                 default n
 957
 958         config KERNEL_JFFS2_FS_POSIX_ACL
 959                 bool "Enable POSIX ACL for JFFS2 Filesystems"
 960                 select KERNEL_FS_POSIX_ACL
 961                 default n
 962
 963         config KERNEL_TMPFS_POSIX_ACL
 964                 bool "Enable POSIX ACL for TMPFS Filesystems"
 965                 select KERNEL_FS_POSIX_ACL
 966                 default n
 967
 968         config KERNEL_CIFS_ACL
 969                 bool "Enable CIFS ACLs"
 970                 select KERNEL_FS_POSIX_ACL
 971                 default y if USE_FS_ACL_ATTR
 972
 973         config KERNEL_HFS_FS_POSIX_ACL
 974                 bool "Enable POSIX ACL for HFS Filesystems"
 975                 select KERNEL_FS_POSIX_ACL
 976                 default y if USE_FS_ACL_ATTR
 977
 978         config KERNEL_HFSPLUS_FS_POSIX_ACL
 979                 bool "Enable POSIX ACL for HFS+ Filesystems"
 980                 select KERNEL_FS_POSIX_ACL
 981                 default y if USE_FS_ACL_ATTR
 982
 983         config KERNEL_NFS_ACL_SUPPORT
 984                 bool "Enable ACLs for NFS"
 985                 default y if USE_FS_ACL_ATTR
 986
 987         config KERNEL_NFS_V3_ACL_SUPPORT
 988                 bool "Enable ACLs for NFSv3"
 989                 default n
 990
 991         config KERNEL_NFSD_V2_ACL_SUPPORT
 992                 bool "Enable ACLs for NFSDv2"
 993                 default n
 994
 995         config KERNEL_NFSD_V3_ACL_SUPPORT
 996                 bool "Enable ACLs for NFSDv3"
 997                 default n
 998
 999         config KERNEL_REISER_FS_POSIX_ACL
1000                 bool "Enable POSIX ACLs for ReiserFS"
1001                 select KERNEL_FS_POSIX_ACL
1002                 default y if USE_FS_ACL_ATTR
1003
1004         config KERNEL_XFS_POSIX_ACL
1005                 bool "Enable POSIX ACLs for XFS"
1006                 select KERNEL_FS_POSIX_ACL
1007                 default y if USE_FS_ACL_ATTR
1008
1009         config KERNEL_JFS_POSIX_ACL
1010                 bool "Enable POSIX ACLs for JFS"
1011                 select KERNEL_FS_POSIX_ACL
1012                 default y if USE_FS_ACL_ATTR
1013
1014 endmenu
1015
1016 config KERNEL_DEVMEM
1017         bool "/dev/mem virtual device support"
1018         help
1019           Say Y here if you want to support the /dev/mem device.
1020           The /dev/mem device is used to access areas of physical
1021           memory.
1022
1023 config KERNEL_DEVKMEM
1024         bool "/dev/kmem virtual device support"
1025         help
1026           Say Y here if you want to support the /dev/kmem device. The
1027           /dev/kmem device is rarely used, but can be used for certain
1028           kind of kernel debugging operations.
1029
1030 config KERNEL_SQUASHFS_FRAGMENT_CACHE_SIZE
1031         int "Number of squashfs fragments cached"
1032         default 2 if (SMALL_FLASH && !LOW_MEMORY_FOOTPRINT)
1033         default 3
1034
1035 #
1036 # compile optimiziation setting
1037 #
1038 choice
1039         prompt "Compiler optimization level"
1040         default KERNEL_CC_OPTIMIZE_FOR_SIZE if SMALL_FLASH
1041
1042 config KERNEL_CC_OPTIMIZE_FOR_PERFORMANCE
1043         bool "Optimize for performance"
1044         help
1045           This is the default optimization level for the kernel, building
1046           with the "-O2" compiler flag for best performance and most
1047           helpful compile-time warnings.
1048
1049 config KERNEL_CC_OPTIMIZE_FOR_SIZE
1050         bool "Optimize for size"
1051         help
1052           Enabling this option will pass "-Os" instead of "-O2" to
1053           your compiler resulting in a smaller kernel.
1054
1055 endchoice