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