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