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_CPUSETS
 269                 bool "Cpuset support"
 270                 default n
 271                 help
 272                   This option will let you create and manage CPUSETs which
 273                   allow dynamically partitioning a system into sets of CPUs and
 274                   Memory Nodes and assigning tasks to run only within those sets.
 275                   This is primarily useful on large SMP or NUMA systems.
 276
 277         config KERNEL_PROC_PID_CPUSET
 278                 bool "Include legacy /proc/<pid>/cpuset file"
 279                 default n
 280                 depends on KERNEL_CPUSETS
 281
 282         config KERNEL_CGROUP_CPUACCT
 283                 bool "Simple CPU accounting cgroup subsystem"
 284                 default n
 285                 help
 286                   Provides a simple Resource Controller for monitoring the
 287                   total CPU consumed by the tasks in a cgroup.
 288
 289         config KERNEL_RESOURCE_COUNTERS
 290                 bool "Resource counters"
 291                 default n
 292                 help
 293                   This option enables controller independent resource accounting
 294                   infrastructure that works with cgroups.
 295
 296         config KERNEL_MM_OWNER
 297                 bool
 298                 default y if KERNEL_MEMCG
 299
 300         config KERNEL_MEMCG
 301                 bool "Memory Resource Controller for Control Groups"
 302                 default n
 303                 depends on KERNEL_RESOURCE_COUNTERS || !LINUX_3_18
 304                 help
 305                   Provides a memory resource controller that manages both anonymous
 306                   memory and page cache. (See Documentation/cgroups/memory.txt)
 307
 308                   Note that setting this option increases fixed memory overhead
 309                   associated with each page of memory in the system. By this,
 310                   20(40)bytes/PAGE_SIZE on 32(64)bit system will be occupied by memory
 311                   usage tracking struct at boot. Total amount of this is printed out
 312                   at boot.
 313
 314                   Only enable when you're ok with these tradeoffs and really
 315                   sure you need the memory resource controller. Even when you enable
 316                   this, you can set "cgroup_disable=memory" at your boot option to
 317                   disable memory resource controller and you can avoid overheads
 318                   (but lose benefits of memory resource controller).
 319
 320                   This config option also selects MM_OWNER config option, which
 321                   could in turn add some fork/exit overhead.
 322
 323         config KERNEL_MEMCG_SWAP
 324                 bool "Memory Resource Controller Swap Extension"
 325                 default n
 326                 depends on KERNEL_MEMCG
 327                 help
 328                   Add swap management feature to memory resource controller. When you
 329                   enable this, you can limit mem+swap usage per cgroup. In other words,
 330                   when you disable this, memory resource controller has no cares to
 331                   usage of swap...a process can exhaust all of the swap. This extension
 332                   is useful when you want to avoid exhaustion swap but this itself
 333                   adds more overheads and consumes memory for remembering information.
 334                   Especially if you use 32bit system or small memory system, please
 335                   be careful about enabling this. When memory resource controller
 336                   is disabled by boot option, this will be automatically disabled and
 337                   there will be no overhead from this. Even when you set this config=y,
 338                   if boot option "swapaccount=0" is set, swap will not be accounted.
 339                   Now, memory usage of swap_cgroup is 2 bytes per entry. If swap page
 340                   size is 4096bytes, 512k per 1Gbytes of swap.
 341
 342         config KERNEL_MEMCG_SWAP_ENABLED
 343                 bool "Memory Resource Controller Swap Extension enabled by default"
 344                 default n
 345                 depends on KERNEL_MEMCG_SWAP
 346                 help
 347                   Memory Resource Controller Swap Extension comes with its price in
 348                   a bigger memory consumption. General purpose distribution kernels
 349                   which want to enable the feature but keep it disabled by default
 350                   and let the user enable it by swapaccount boot command line
 351                   parameter should have this option unselected.
 352
 353                   Those who want to have the feature enabled by default should
 354                   select this option (if, for some reason, they need to disable it,
 355                   then swapaccount=0 does the trick).
 356
 357
 358         config KERNEL_MEMCG_KMEM
 359                 bool "Memory Resource Controller Kernel Memory accounting (EXPERIMENTAL)"
 360                 default n
 361                 depends on KERNEL_MEMCG
 362                 help
 363                   The Kernel Memory extension for Memory Resource Controller can limit
 364                   the amount of memory used by kernel objects in the system. Those are
 365                   fundamentally different from the entities handled by the standard
 366                   Memory Controller, which are page-based, and can be swapped. Users of
 367                   the kmem extension can use it to guarantee that no group of processes
 368                   will ever exhaust kernel resources alone.
 369
 370         config KERNEL_CGROUP_PERF
 371                 bool "Enable perf_event per-cpu per-container group (cgroup) monitoring"
 372                 select KERNEL_PERF_EVENTS
 373                 default n
 374                 help
 375                   This option extends the per-cpu mode to restrict monitoring to
 376                   threads which belong to the cgroup specified and run on the
 377                   designated cpu.
 378
 379         menuconfig KERNEL_CGROUP_SCHED
 380                 bool "Group CPU scheduler"
 381                 default n
 382                 help
 383                   This feature lets CPU scheduler recognize task groups and control CPU
 384                   bandwidth allocation to such task groups. It uses cgroups to group
 385                   tasks.
 386
 387         if KERNEL_CGROUP_SCHED
 388
 389                 config KERNEL_FAIR_GROUP_SCHED
 390                         bool "Group scheduling for SCHED_OTHER"
 391                         default n
 392
 393                 config KERNEL_CFS_BANDWIDTH
 394                         bool "CPU bandwidth provisioning for FAIR_GROUP_SCHED"
 395                         default n
 396                         depends on KERNEL_FAIR_GROUP_SCHED
 397                         help
 398                           This option allows users to define CPU bandwidth rates (limits) for
 399                           tasks running within the fair group scheduler.  Groups with no limit
 400                           set are considered to be unconstrained and will run with no
 401                           restriction.
 402                           See tip/Documentation/scheduler/sched-bwc.txt for more information.
 403
 404                 config KERNEL_RT_GROUP_SCHED
 405                         bool "Group scheduling for SCHED_RR/FIFO"
 406                         default n
 407                         help
 408                           This feature lets you explicitly allocate real CPU bandwidth
 409                           to task groups. If enabled, it will also make it impossible to
 410                           schedule realtime tasks for non-root users until you allocate
 411                           realtime bandwidth for them.
 412
 413         endif
 414
 415         config KERNEL_BLK_CGROUP
 416                 bool "Block IO controller"
 417                 default y
 418                 help
 419                   Generic block IO controller cgroup interface. This is the common
 420                   cgroup interface which should be used by various IO controlling
 421                   policies.
 422
 423                   Currently, CFQ IO scheduler uses it to recognize task groups and
 424                   control disk bandwidth allocation (proportional time slice allocation)
 425                   to such task groups. It is also used by bio throttling logic in
 426                   block layer to implement upper limit in IO rates on a device.
 427
 428                   This option only enables generic Block IO controller infrastructure.
 429                   One needs to also enable actual IO controlling logic/policy. For
 430                   enabling proportional weight division of disk bandwidth in CFQ, set
 431                   CONFIG_CFQ_GROUP_IOSCHED=y; for enabling throttling policy, set
 432                   CONFIG_BLK_DEV_THROTTLING=y.
 433
 434         config KERNEL_DEBUG_BLK_CGROUP
 435                 bool "Enable Block IO controller debugging"
 436                 default n
 437                 depends on KERNEL_BLK_CGROUP
 438                 help
 439                   Enable some debugging help. Currently it exports additional stat
 440                   files in a cgroup which can be useful for debugging.
 441
 442         config KERNEL_NET_CLS_CGROUP
 443                 bool "Control Group Classifier"
 444                 default y
 445
 446         config KERNEL_NETPRIO_CGROUP
 447                 bool "Network priority cgroup"
 448                 default y
 449
 450 endif
 451
 452 #
 453 # Namespace support symbols
 454 #
 455
 456 config KERNEL_NAMESPACES
 457         bool "Enable kernel namespaces"
 458         default n
 459
 460 if KERNEL_NAMESPACES
 461
 462         config KERNEL_UTS_NS
 463                 bool "UTS namespace"
 464                 default y
 465                 help
 466                   In this namespace, tasks see different info provided
 467                   with the uname() system call.
 468
 469         config KERNEL_IPC_NS
 470                 bool "IPC namespace"
 471                 default y
 472                 help
 473                   In this namespace, tasks work with IPC ids which correspond to
 474                   different IPC objects in different namespaces.
 475
 476         config KERNEL_USER_NS
 477                 bool "User namespace (EXPERIMENTAL)"
 478                 default y
 479                 help
 480                   This allows containers, i.e. vservers, to use user namespaces
 481                   to provide different user info for different servers.
 482
 483         config KERNEL_PID_NS
 484                 bool "PID Namespaces"
 485                 default y
 486                 help
 487                   Support process id namespaces. This allows having multiple
 488                   processes with the same pid as long as they are in different
 489                   pid namespaces. This is a building block of containers.
 490
 491         config KERNEL_NET_NS
 492                 bool "Network namespace"
 493                 default y
 494                 help
 495                   Allow user space to create what appear to be multiple instances
 496                   of the network stack.
 497
 498 endif
 499
 500 #
 501 # LXC related symbols
 502 #
 503
 504 config KERNEL_LXC_MISC
 505         bool "Enable miscellaneous LXC related options"
 506         default n
 507
 508 if KERNEL_LXC_MISC
 509
 510         config KERNEL_DEVPTS_MULTIPLE_INSTANCES
 511                 bool "Support multiple instances of devpts"
 512                 default y
 513                 help
 514                   Enable support for multiple instances of devpts filesystem.
 515                   If you want to have isolated PTY namespaces (eg: in containers),
 516                   say Y here. Otherwise, say N. If enabled, each mount of devpts
 517                   filesystem with the '-o newinstance' option will create an
 518                   independent PTY namespace.
 519
 520         config KERNEL_POSIX_MQUEUE
 521                 bool "POSIX Message Queues"
 522                 default y
 523                 help
 524                   POSIX variant of message queues is a part of IPC. In POSIX message
 525                   queues every message has a priority which decides about succession
 526                   of receiving it by a process. If you want to compile and run
 527                   programs written e.g. for Solaris with use of its POSIX message
 528                   queues (functions mq_*) say Y here.
 529
 530                   POSIX message queues are visible as a filesystem called 'mqueue'
 531                   and can be mounted somewhere if you want to do filesystem
 532                   operations on message queues.
 533
 534 endif
 535
 536 config KERNEL_SECCOMP_FILTER
 537         bool
 538         default n
 539
 540 config KERNEL_SECCOMP
 541         bool "Enable seccomp support"
 542                 depends on !(TARGET_uml)
 543                 select KERNEL_SECCOMP_FILTER
 544                 default n
 545                 help
 546                   Build kernel with support for seccomp.