Config-kernel.in

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