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