config/Config-kernel.in

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