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