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