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