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