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