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