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_PRINTK
   8         bool "Enable support for printk"
   9         default y
  10
  11 config KERNEL_CRASHLOG
  12         bool "Crash logging"
  13         depends on !(arm || powerpc || sparc || TARGET_uml)
  14         default y
  15
  16 config KERNEL_SWAP
  17         bool "Support for paging of anonymous memory (swap)"
  18         default y
  19
  20 config KERNEL_DEBUG_FS
  21         bool "Compile the kernel with debug filesystem enabled"
  22         default y
  23         help
  24           debugfs is a virtual file system that kernel developers use to put
  25           debugging files into. Enable this option to be able to read and
  26           write to these files. Many common debugging facilities, such as
  27           ftrace, require the existence of debugfs.
  28
  29 config KERNEL_PERF_EVENTS
  30         bool
  31         default n
  32
  33 config KERNEL_PROFILING
  34         bool "Compile the kernel with profiling enabled"
  35         default n
  36         select KERNEL_PERF_EVENTS
  37         help
  38           Enable the extended profiling support mechanisms used by profilers such
  39           as OProfile.
  40
  41 config KERNEL_KALLSYMS
  42         bool "Compile the kernel with symbol table information"
  43         default y
  44         help
  45           This will give you more information in stack traces from kernel oopses.
  46
  47 config KERNEL_FTRACE
  48         bool "Compile the kernel with tracing support"
  49         depends on !TARGET_uml
  50         default n
  51
  52 config KERNEL_FTRACE_SYSCALLS
  53         bool "Trace system calls"
  54         depends on KERNEL_FTRACE
  55         default n
  56
  57 config KERNEL_ENABLE_DEFAULT_TRACERS
  58         bool "Trace process context switches and events"
  59         depends on KERNEL_FTRACE
  60         default n
  61
  62 config KERNEL_FUNCTION_TRACER
  63         bool "Function tracer"
  64         depends on KERNEL_FTRACE
  65         default n
  66
  67 config KERNEL_FUNCTION_GRAPH_TRACER
  68         bool "Function graph tracer"
  69         depends on KERNEL_FUNCTION_TRACER
  70         default n
  71
  72 config KERNEL_DYNAMIC_FTRACE
  73         bool "Enable/disable function tracing dynamically"
  74         depends on KERNEL_FUNCTION_TRACER
  75         default n
  76
  77 config KERNEL_FUNCTION_PROFILER
  78         bool "Function profiler"
  79         depends on KERNEL_FUNCTION_TRACER
  80         default n
  81
  82 config KERNEL_DEBUG_KERNEL
  83         bool
  84         default n
  85
  86 config KERNEL_DEBUG_INFO
  87         bool "Compile the kernel with debug information"
  88         default y
  89         select KERNEL_DEBUG_KERNEL
  90         help
  91           This will compile your kernel and modules with debug information.
  92
  93 config KERNEL_DEBUG_LL_UART_NONE
  94         bool
  95         default n
  96         depends on arm
  97
  98 config KERNEL_DEBUG_LL
  99         bool
 100         default n
 101         depends on arm
 102         select KERNEL_DEBUG_LL_UART_NONE
 103         help
 104           ARM low level debugging.
 105
 106 config KERNEL_DYNAMIC_DEBUG
 107         bool "Compile the kernel with dynamic printk"
 108         select KERNEL_DEBUG_FS
 109         default n
 110         help
 111           Compiles debug level messages into the kernel, which would not
 112           otherwise be available at runtime. These messages can then be
 113           enabled/disabled based on various levels of scope - per source file,
 114           function, module, format string, and line number. This mechanism
 115           implicitly compiles in all pr_debug() and dev_dbg() calls, which
 116           enlarges the kernel text size by about 2%.
 117
 118 config KERNEL_EARLY_PRINTK
 119         bool "Compile the kernel with early printk"
 120         default y if TARGET_bcm53xx
 121         default n
 122         depends on arm
 123         select KERNEL_DEBUG_KERNEL
 124         select KERNEL_DEBUG_LL if arm
 125         help
 126           Compile the kernel with early printk support.  This is only useful for
 127           debugging purposes to send messages over the serial console in early boot.
 128           Enable this to debug early boot problems.
 129
 130 config KERNEL_AIO
 131         bool "Compile the kernel with asynchronous IO support"
 132         default n
 133
 134 config KERNEL_DIRECT_IO
 135         bool "Compile the kernel with direct IO support"
 136         default n
 137
 138 config KERNEL_MAGIC_SYSRQ
 139         bool "Compile the kernel with SysRq support"
 140         default y
 141
 142 config KERNEL_COREDUMP
 143         bool
 144
 145 config KERNEL_ELF_CORE
 146         bool "Enable process core dump support"
 147         select KERNEL_COREDUMP
 148         default y
 149
 150 config KERNEL_PROVE_LOCKING
 151         bool "Enable kernel lock checking"
 152         select KERNEL_DEBUG_KERNEL
 153         default n
 154
 155 config KERNEL_PRINTK_TIME
 156         bool "Enable printk timestamps"
 157         default y
 158
 159 config KERNEL_SLUB_DEBUG
 160         bool
 161
 162 config KERNEL_SLUB_DEBUG_ON
 163         bool
 164
 165 config KERNEL_SLABINFO
 166         select KERNEL_SLUB_DEBUG
 167         select KERNEL_SLUB_DEBUG_ON
 168         bool "Enable /proc slab debug info"
 169
 170 config KERNEL_PROC_PAGE_MONITOR
 171         bool "Enable /proc page monitoring"
 172
 173 config KERNEL_RELAY
 174         bool
 175
 176 config KERNEL_KEXEC
 177         bool "Enable kexec support"
 178
 179 config USE_RFKILL
 180         bool "Enable rfkill support"
 181         default RFKILL_SUPPORT
 182
 183 config USE_SPARSE
 184         bool "Enable sparse check during kernel build"
 185         default n
 186
 187 #
 188 # CGROUP support symbols
 189 #
 190
 191 config KERNEL_CGROUPS
 192         bool "Enable kernel cgroups"
 193         default n
 194
 195 if KERNEL_CGROUPS
 196
 197         config KERNEL_CGROUP_DEBUG
 198                 bool "Example debug cgroup subsystem"
 199                 default n
 200                 help
 201                   This option enables a simple cgroup subsystem that
 202                   exports useful debugging information about the cgroups
 203                   framework.
 204
 205         config KERNEL_FREEZER
 206                 bool
 207                 default y if KERNEL_CGROUP_FREEZER
 208
 209         config KERNEL_CGROUP_FREEZER
 210                 bool "Freezer cgroup subsystem"
 211                 default y
 212                 help
 213                   Provides a way to freeze and unfreeze all tasks in a
 214                   cgroup.
 215
 216         config KERNEL_CGROUP_DEVICE
 217                 bool "Device controller for cgroups"
 218                 default y
 219                 help
 220                   Provides a cgroup implementing whitelists for devices which
 221                   a process in the cgroup can mknod or open.
 222
 223         config KERNEL_CPUSETS
 224                 bool "Cpuset support"
 225                 default n
 226                 help
 227                   This option will let you create and manage CPUSETs which
 228                   allow dynamically partitioning a system into sets of CPUs and
 229                   Memory Nodes and assigning tasks to run only within those sets.
 230                   This is primarily useful on large SMP or NUMA systems.
 231
 232         config KERNEL_PROC_PID_CPUSET
 233                 bool "Include legacy /proc/<pid>/cpuset file"
 234                 default n
 235                 depends on KERNEL_CPUSETS
 236
 237         config KERNEL_CGROUP_CPUACCT
 238                 bool "Simple CPU accounting cgroup subsystem"
 239                 default n
 240                 help
 241                   Provides a simple Resource Controller for monitoring the
 242                   total CPU consumed by the tasks in a cgroup.
 243
 244         config KERNEL_RESOURCE_COUNTERS
 245                 bool "Resource counters"
 246                 default n
 247                 help
 248                   This option enables controller independent resource accounting
 249                   infrastructure that works with cgroups.
 250
 251         config KERNEL_MM_OWNER
 252                 bool
 253                 default y if KERNEL_MEMCG
 254
 255         config KERNEL_MEMCG
 256                 bool "Memory Resource Controller for Control Groups"
 257                 default n
 258                 depends on KERNEL_RESOURCE_COUNTERS
 259                 help
 260                   Provides a memory resource controller that manages both anonymous
 261                   memory and page cache. (See Documentation/cgroups/memory.txt)
 262
 263                   Note that setting this option increases fixed memory overhead
 264                   associated with each page of memory in the system. By this,
 265                   20(40)bytes/PAGE_SIZE on 32(64)bit system will be occupied by memory
 266                   usage tracking struct at boot. Total amount of this is printed out
 267                   at boot.
 268
 269                   Only enable when you're ok with these tradeoffs and really
 270                   sure you need the memory resource controller. Even when you enable
 271                   this, you can set "cgroup_disable=memory" at your boot option to
 272                   disable memory resource controller and you can avoid overheads
 273                   (but lose benefits of memory resource controller).
 274
 275                   This config option also selects MM_OWNER config option, which
 276                   could in turn add some fork/exit overhead.
 277
 278         config KERNEL_MEMCG_SWAP
 279                 bool "Memory Resource Controller Swap Extension"
 280                 default n
 281                 depends on KERNEL_MEMCG
 282                 help
 283                   Add swap management feature to memory resource controller. When you
 284                   enable this, you can limit mem+swap usage per cgroup. In other words,
 285                   when you disable this, memory resource controller has no cares to
 286                   usage of swap...a process can exhaust all of the swap. This extension
 287                   is useful when you want to avoid exhaustion swap but this itself
 288                   adds more overheads and consumes memory for remembering information.
 289                   Especially if you use 32bit system or small memory system, please
 290                   be careful about enabling this. When memory resource controller
 291                   is disabled by boot option, this will be automatically disabled and
 292                   there will be no overhead from this. Even when you set this config=y,
 293                   if boot option "swapaccount=0" is set, swap will not be accounted.
 294                   Now, memory usage of swap_cgroup is 2 bytes per entry. If swap page
 295                   size is 4096bytes, 512k per 1Gbytes of swap.
 296
 297         config KERNEL_MEMCG_SWAP_ENABLED
 298                 bool "Memory Resource Controller Swap Extension enabled by default"
 299                 default n
 300                 depends on KERNEL_MEMCG_SWAP
 301                 help
 302                   Memory Resource Controller Swap Extension comes with its price in
 303                   a bigger memory consumption. General purpose distribution kernels
 304                   which want to enable the feature but keep it disabled by default
 305                   and let the user enable it by swapaccount boot command line
 306                   parameter should have this option unselected.
 307
 308                   Those who want to have the feature enabled by default should
 309                   select this option (if, for some reason, they need to disable it,
 310                   then swapaccount=0 does the trick).
 311
 312
 313         config KERNEL_MEMCG_KMEM
 314                 bool "Memory Resource Controller Kernel Memory accounting (EXPERIMENTAL)"
 315                 default n
 316                 depends on KERNEL_MEMCG
 317                 help
 318                   The Kernel Memory extension for Memory Resource Controller can limit
 319                   the amount of memory used by kernel objects in the system. Those are
 320                   fundamentally different from the entities handled by the standard
 321                   Memory Controller, which are page-based, and can be swapped. Users of
 322                   the kmem extension can use it to guarantee that no group of processes
 323                   will ever exhaust kernel resources alone.
 324
 325         config KERNEL_CGROUP_PERF
 326                 bool "Enable perf_event per-cpu per-container group (cgroup) monitoring"
 327                 select KERNEL_PERF_EVENTS
 328                 default n
 329                 help
 330                   This option extends the per-cpu mode to restrict monitoring to
 331                   threads which belong to the cgroup specified and run on the
 332                   designated cpu.
 333
 334         menuconfig KERNEL_CGROUP_SCHED
 335                 bool "Group CPU scheduler"
 336                 default n
 337                 help
 338                   This feature lets CPU scheduler recognize task groups and control CPU
 339                   bandwidth allocation to such task groups. It uses cgroups to group
 340                   tasks.
 341
 342         if KERNEL_CGROUP_SCHED
 343
 344                 config KERNEL_FAIR_GROUP_SCHED
 345                         bool "Group scheduling for SCHED_OTHER"
 346                         default n
 347
 348                 config KERNEL_CFS_BANDWIDTH
 349                         bool "CPU bandwidth provisioning for FAIR_GROUP_SCHED"
 350                         default n
 351                         depends on KERNEL_FAIR_GROUP_SCHED
 352                         help
 353                           This option allows users to define CPU bandwidth rates (limits) for
 354                           tasks running within the fair group scheduler.  Groups with no limit
 355                           set are considered to be unconstrained and will run with no
 356                           restriction.
 357                           See tip/Documentation/scheduler/sched-bwc.txt for more information.
 358
 359                 config KERNEL_RT_GROUP_SCHED
 360                         bool "Group scheduling for SCHED_RR/FIFO"
 361                         default n
 362                         help
 363                           This feature lets you explicitly allocate real CPU bandwidth
 364                           to task groups. If enabled, it will also make it impossible to
 365                           schedule realtime tasks for non-root users until you allocate
 366                           realtime bandwidth for them.
 367
 368         endif
 369
 370         config KERNEL_BLK_CGROUP
 371                 bool "Block IO controller"
 372                 default y
 373                 help
 374                   Generic block IO controller cgroup interface. This is the common
 375                   cgroup interface which should be used by various IO controlling
 376                   policies.
 377
 378                   Currently, CFQ IO scheduler uses it to recognize task groups and
 379                   control disk bandwidth allocation (proportional time slice allocation)
 380                   to such task groups. It is also used by bio throttling logic in
 381                   block layer to implement upper limit in IO rates on a device.
 382
 383                   This option only enables generic Block IO controller infrastructure.
 384                   One needs to also enable actual IO controlling logic/policy. For
 385                   enabling proportional weight division of disk bandwidth in CFQ, set
 386                   CONFIG_CFQ_GROUP_IOSCHED=y; for enabling throttling policy, set
 387                   CONFIG_BLK_DEV_THROTTLING=y.
 388
 389         config KERNEL_DEBUG_BLK_CGROUP
 390                 bool "Enable Block IO controller debugging"
 391                 default n
 392                 depends on KERNEL_BLK_CGROUP
 393                 help
 394                   Enable some debugging help. Currently it exports additional stat
 395                   files in a cgroup which can be useful for debugging.
 396
 397         config KERNEL_NET_CLS_CGROUP
 398                 bool "Control Group Classifier"
 399                 default y
 400
 401         config KERNEL_NETPRIO_CGROUP
 402                 bool "Network priority cgroup"
 403                 default y
 404
 405 endif
 406
 407 #
 408 # Namespace support symbols
 409 #
 410
 411 config KERNEL_NAMESPACES
 412         bool "Enable kernel namespaces"
 413         default n
 414
 415 if KERNEL_NAMESPACES
 416
 417         config KERNEL_UTS_NS
 418                 bool "UTS namespace"
 419                 default y
 420                 help
 421                   In this namespace, tasks see different info provided
 422                   with the uname() system call.
 423
 424         config KERNEL_IPC_NS
 425                 bool "IPC namespace"
 426                 default y
 427                 help
 428                   In this namespace, tasks work with IPC ids which correspond to
 429                   different IPC objects in different namespaces.
 430
 431         config KERNEL_USER_NS
 432                 bool "User namespace (EXPERIMENTAL)"
 433                 default y
 434                 help
 435                   This allows containers, i.e. vservers, to use user namespaces
 436                   to provide different user info for different servers.
 437
 438         config KERNEL_PID_NS
 439                 bool "PID Namespaces"
 440                 default y
 441                 help
 442                   Support process id namespaces. This allows having multiple
 443                   processes with the same pid as long as they are in different
 444                   pid namespaces. This is a building block of containers.
 445
 446         config KERNEL_NET_NS
 447                 bool "Network namespace"
 448                 default y
 449                 help
 450                   Allow user space to create what appear to be multiple instances
 451                   of the network stack.
 452
 453 endif
 454
 455 #
 456 # LXC related symbols
 457 #
 458
 459 config KERNEL_LXC_MISC
 460         bool "Enable miscellaneous LXC related options"
 461         default n
 462
 463 if KERNEL_LXC_MISC
 464
 465         config KERNEL_DEVPTS_MULTIPLE_INSTANCES
 466                 bool "Support multiple instances of devpts"
 467                 default y
 468                 help
 469                   Enable support for multiple instances of devpts filesystem.
 470                   If you want to have isolated PTY namespaces (eg: in containers),
 471                   say Y here. Otherwise, say N. If enabled, each mount of devpts
 472                   filesystem with the '-o newinstance' option will create an
 473                   independent PTY namespace.
 474
 475         config KERNEL_POSIX_MQUEUE
 476                 bool "POSIX Message Queues"
 477                 default y
 478                 help
 479                   POSIX variant of message queues is a part of IPC. In POSIX message
 480                   queues every message has a priority which decides about succession
 481                   of receiving it by a process. If you want to compile and run
 482                   programs written e.g. for Solaris with use of its POSIX message
 483                   queues (functions mq_*) say Y here.
 484
 485                   POSIX message queues are visible as a filesystem called 'mqueue'
 486                   and can be mounted somewhere if you want to do filesystem
 487                   operations on message queues.
 488
 489 endif
 490
 491 config KERNEL_SECCOMP
 492         bool "Enable seccomp support"
 493                 depends on !(TARGET_uml || TARGET_avr32)
 494                 default n
 495                 help
 496                   Build kernel with support for seccomp.
 497
 498 config KERNEL_SECCOMP_FILTER
 499         bool "Enable seccomp filter support"
 500                 depends on KERNEL_SECCOMP
 501                 default n
 502                 help
 503                   Build kernel with support for seccomp BPF programs.
 504
 505 config KERNEL_FHANDLE
 506         bool "Enable open by fhandle syscalls"
 507                 default n
 508                 help
 509                   Build kernel with support for open by fhandle syscalls