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