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