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