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