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 "builder" if BUILDBOT
  10         default ""
  11         help
  12           Sets the Kernel build user string, which for example will be returned
  13           by 'uname -a' on running systems.
  14           If not set, uses system user at build time.
  15
  16 config KERNEL_BUILD_DOMAIN
  17         string "Custom Kernel Build Domain Name"
  18         default "buildhost" if BUILDBOT
  19         default ""
  20         help
  21           Sets the Kernel build domain string, which for example will be
  22           returned by 'uname -a' on running systems.
  23           If not set, uses system hostname at build time.
  24
  25 config KERNEL_PRINTK
  26         bool "Enable support for printk"
  27         default y
  28
  29 config KERNEL_CRASHLOG
  30         bool "Crash logging"
  31         depends on !(arm || powerpc || sparc || TARGET_uml || i386 || x86_64)
  32         default y
  33
  34 config KERNEL_SWAP
  35         bool "Support for paging of anonymous memory (swap)"
  36         default y if !SMALL_FLASH
  37
  38 config KERNEL_DEBUG_FS
  39         bool "Compile the kernel with debug filesystem enabled"
  40         default y
  41         help
  42           debugfs is a virtual file system that kernel developers use to put
  43           debugging files into. Enable this option to be able to read and
  44           write to these files. Many common debugging facilities, such as
  45           ftrace, require the existence of debugfs.
  46
  47 config KERNEL_MIPS_FPU_EMULATOR
  48         bool "Compile the kernel with MIPS FPU Emulator"
  49         default y if TARGET_pistachio
  50         depends on (mips || mipsel || mips64 || mips64el)
  51
  52 config KERNEL_ARM_PMU
  53         bool
  54         default n
  55         depends on (arm || aarch64)
  56
  57 config KERNEL_X86_VSYSCALL_EMULATION
  58         bool "Enable vsyscall emulation"
  59         default n
  60         depends on x86_64
  61         help
  62           This enables emulation of the legacy vsyscall page.  Disabling
  63           it is roughly equivalent to booting with vsyscall=none, except
  64           that it will also disable the helpful warning if a program
  65           tries to use a vsyscall.  With this option set to N, offending
  66           programs will just segfault, citing addresses of the form
  67           0xffffffffff600?00.
  68
  69           This option is required by many programs built before 2013, and
  70           care should be used even with newer programs if set to N.
  71
  72           Disabling this option saves about 7K of kernel size and
  73           possibly 4K of additional runtime pagetable memory.
  74
  75 config KERNEL_PERF_EVENTS
  76         bool "Compile the kernel with performance events and counters"
  77         default n
  78         select KERNEL_ARM_PMU if (arm || aarch64)
  79
  80 config KERNEL_PROFILING
  81         bool "Compile the kernel with profiling enabled"
  82         default n
  83         select KERNEL_PERF_EVENTS
  84         help
  85           Enable the extended profiling support mechanisms used by profilers such
  86           as OProfile.
  87
  88 config KERNEL_UBSAN
  89         bool "Compile the kernel with undefined behaviour sanity checker"
  90         help
  91           This option enables undefined behaviour sanity checker
  92           Compile-time instrumentation is used to detect various undefined
  93           behaviours in runtime. Various types of checks may be enabled
  94           via boot parameter ubsan_handle
  95           (see: Documentation/dev-tools/ubsan.rst).
  96
  97 config KERNEL_UBSAN_SANITIZE_ALL
  98         bool "Enable instrumentation for the entire kernel"
  99         depends on KERNEL_UBSAN
 100         default y
 101         help
 102           This option activates instrumentation for the entire kernel.
 103           If you don't enable this option, you have to explicitly specify
 104           UBSAN_SANITIZE := y for the files/directories you want to check for UB.
 105           Enabling this option will get kernel image size increased
 106           significantly.
 107
 108 config KERNEL_UBSAN_ALIGNMENT
 109         bool "Enable checking of pointers alignment"
 110         depends on KERNEL_UBSAN
 111         help
 112           This option enables detection of unaligned memory accesses.
 113           Enabling this option on architectures that support unaligned
 114           accesses may produce a lot of false positives.
 115
 116 config KERNEL_UBSAN_NULL
 117         bool "Enable checking of null pointers"
 118         depends on KERNEL_UBSAN
 119         help
 120           This option enables detection of memory accesses via a
 121           null pointer.
 122
 123 config KERNEL_KASAN
 124         bool "Compile the kernel with KASan: runtime memory debugger"
 125         select KERNEL_SLUB_DEBUG
 126         depends on (x86_64 || aarch64)
 127         help
 128           Enables kernel address sanitizer - runtime memory debugger,
 129           designed to find out-of-bounds accesses and use-after-free bugs.
 130           This is strictly a debugging feature and it requires a gcc version
 131           of 4.9.2 or later. Detection of out of bounds accesses to stack or
 132           global variables requires gcc 5.0 or later.
 133           This feature consumes about 1/8 of available memory and brings about
 134           ~x3 performance slowdown.
 135           For better error detection enable CONFIG_STACKTRACE.
 136           Currently CONFIG_KASAN doesn't work with CONFIG_DEBUG_SLAB
 137           (the resulting kernel does not boot).
 138
 139 config KERNEL_KASAN_EXTRA
 140         bool "KAsan: extra checks"
 141         depends on KERNEL_KASAN && KERNEL_DEBUG_KERNEL
 142         help
 143           This enables further checks in the kernel address sanitizer, for now
 144           it only includes the address-use-after-scope check that can lead
 145           to excessive kernel stack usage, frame size warnings and longer
 146           compile time.
 147           https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81715 has more
 148
 149
 150 choice
 151         prompt "Instrumentation type"
 152         depends on KERNEL_KASAN
 153         default KERNEL_KASAN_OUTLINE
 154
 155 config KERNEL_KASAN_OUTLINE
 156         bool "Outline instrumentation"
 157         help
 158           Before every memory access compiler insert function call
 159           __asan_load*/__asan_store*. These functions performs check
 160           of shadow memory. This is slower than inline instrumentation,
 161           however it doesn't bloat size of kernel's .text section so
 162           much as inline does.
 163
 164 config KERNEL_KASAN_INLINE
 165         bool "Inline instrumentation"
 166         help
 167           Compiler directly inserts code checking shadow memory before
 168           memory accesses. This is faster than outline (in some workloads
 169           it gives about x2 boost over outline instrumentation), but
 170           make kernel's .text size much bigger.
 171           This requires a gcc version of 5.0 or later.
 172
 173 endchoice
 174
 175 config KERNEL_TASKSTATS
 176         bool "Compile the kernel with task resource/io statistics and accounting"
 177         default n
 178         help
 179           Enable the collection and publishing of task/io statistics and
 180           accounting.  Enable this option to enable i/o monitoring in system
 181           monitors.
 182
 183 if KERNEL_TASKSTATS
 184
 185         config KERNEL_TASK_DELAY_ACCT
 186                 def_bool y
 187
 188         config KERNEL_TASK_IO_ACCOUNTING
 189                 def_bool y
 190
 191         config KERNEL_TASK_XACCT
 192                 def_bool y
 193
 194 endif
 195
 196 config KERNEL_KALLSYMS
 197         bool "Compile the kernel with symbol table information"
 198         default y if !SMALL_FLASH
 199         help
 200           This will give you more information in stack traces from kernel oopses.
 201
 202 config KERNEL_FTRACE
 203         bool "Compile the kernel with tracing support"
 204         depends on !TARGET_uml
 205         default n
 206
 207 config KERNEL_FTRACE_SYSCALLS
 208         bool "Trace system calls"
 209         depends on KERNEL_FTRACE
 210         default n
 211
 212 config KERNEL_ENABLE_DEFAULT_TRACERS
 213         bool "Trace process context switches and events"
 214         depends on KERNEL_FTRACE
 215         default n
 216
 217 config KERNEL_FUNCTION_TRACER
 218         bool "Function tracer"
 219         depends on KERNEL_FTRACE
 220         default n
 221
 222 config KERNEL_FUNCTION_GRAPH_TRACER
 223         bool "Function graph tracer"
 224         depends on KERNEL_FUNCTION_TRACER
 225         default n
 226
 227 config KERNEL_DYNAMIC_FTRACE
 228         bool "Enable/disable function tracing dynamically"
 229         depends on KERNEL_FUNCTION_TRACER
 230         default n
 231
 232 config KERNEL_FUNCTION_PROFILER
 233         bool "Function profiler"
 234         depends on KERNEL_FUNCTION_TRACER
 235         default n
 236
 237 config KERNEL_DEBUG_KERNEL
 238         bool
 239         default n
 240
 241 config KERNEL_DEBUG_INFO
 242         bool "Compile the kernel with debug information"
 243         default y if !SMALL_FLASH
 244         select KERNEL_DEBUG_KERNEL
 245         help
 246           This will compile your kernel and modules with debug information.
 247
 248 config KERNEL_DEBUG_LL_UART_NONE
 249         bool
 250         default n
 251         depends on arm
 252
 253 config KERNEL_DEBUG_LL
 254         bool
 255         default n
 256         depends on arm
 257         select KERNEL_DEBUG_LL_UART_NONE
 258         help
 259           ARM low level debugging.
 260
 261 config KERNEL_DYNAMIC_DEBUG
 262         bool "Compile the kernel with dynamic printk"
 263         select KERNEL_DEBUG_FS
 264         default n
 265         help
 266           Compiles debug level messages into the kernel, which would not
 267           otherwise be available at runtime. These messages can then be
 268           enabled/disabled based on various levels of scope - per source file,
 269           function, module, format string, and line number. This mechanism
 270           implicitly compiles in all pr_debug() and dev_dbg() calls, which
 271           enlarges the kernel text size by about 2%.
 272
 273 config KERNEL_EARLY_PRINTK
 274         bool "Compile the kernel with early printk"
 275         default y if TARGET_bcm53xx
 276         default n
 277         depends on arm
 278         select KERNEL_DEBUG_KERNEL
 279         select KERNEL_DEBUG_LL if arm
 280         help
 281           Compile the kernel with early printk support.  This is only useful for
 282           debugging purposes to send messages over the serial console in early boot.
 283           Enable this to debug early boot problems.
 284
 285 config KERNEL_KPROBES
 286         bool "Compile the kernel with kprobes support"
 287         default n
 288         select KERNEL_FTRACE
 289         select KERNEL_PERF_EVENTS
 290         help
 291           Compiles the kernel with KPROBES support, which allows you to trap
 292           at almost any kernel address and execute a callback function.
 293           register_kprobe() establishes a probepoint and specifies the
 294           callback. Kprobes is useful for kernel debugging, non-intrusive
 295           instrumentation and testing.
 296           If in doubt, say "N".
 297
 298 config KERNEL_KPROBE_EVENT
 299         bool
 300         default y if KERNEL_KPROBES
 301
 302 config KERNEL_KPROBE_EVENTS
 303         bool
 304         default y if KERNEL_KPROBES
 305
 306 config KERNEL_AIO
 307         bool "Compile the kernel with asynchronous IO support"
 308         default y if !SMALL_FLASH
 309
 310 config KERNEL_FHANDLE
 311         bool "Compile the kernel with support for fhandle syscalls"
 312         default y if !SMALL_FLASH
 313
 314 config KERNEL_FANOTIFY
 315         bool "Compile the kernel with modern file notification support"
 316         default y if !SMALL_FLASH
 317
 318 config KERNEL_BLK_DEV_BSG
 319         bool "Compile the kernel with SCSI generic v4 support for any block device"
 320         default n
 321
 322 config KERNEL_MAGIC_SYSRQ
 323         bool "Compile the kernel with SysRq support"
 324         default y
 325
 326 config KERNEL_DEBUG_PINCTRL
 327         bool "Compile the kernel with pinctrl debugging"
 328         select KERNEL_DEBUG_KERNEL
 329
 330 config KERNEL_DEBUG_GPIO
 331         bool "Compile the kernel with gpio debugging"
 332         select KERNEL_DEBUG_KERNEL
 333
 334 config KERNEL_COREDUMP
 335         bool
 336
 337 config KERNEL_ELF_CORE
 338         bool "Enable process core dump support"
 339         select KERNEL_COREDUMP
 340         default y if !SMALL_FLASH
 341
 342 config KERNEL_PROVE_LOCKING
 343         bool "Enable kernel lock checking"
 344         select KERNEL_DEBUG_KERNEL
 345         default n
 346
 347 config KERNEL_PRINTK_TIME
 348         bool "Enable printk timestamps"
 349         default y
 350
 351 config KERNEL_SLUB_DEBUG
 352         bool
 353
 354 config KERNEL_SLUB_DEBUG_ON
 355         bool
 356
 357 config KERNEL_SLABINFO
 358         select KERNEL_SLUB_DEBUG
 359         select KERNEL_SLUB_DEBUG_ON
 360         bool "Enable /proc slab debug info"
 361
 362 config KERNEL_PROC_PAGE_MONITOR
 363         bool "Enable /proc page monitoring"
 364
 365 config KERNEL_RELAY
 366         bool
 367
 368 config KERNEL_KEXEC
 369         bool "Enable kexec support"
 370
 371 config KERNEL_PROC_VMCORE
 372         bool
 373
 374 config KERNEL_CRASH_DUMP
 375         depends on i386 || x86_64 || arm || armeb
 376         select KERNEL_KEXEC
 377         select KERNEL_PROC_VMCORE
 378         bool "Enable support for kexec crashdump"
 379         default y
 380
 381 config USE_RFKILL
 382         bool "Enable rfkill support"
 383         default RFKILL_SUPPORT
 384
 385 config USE_SPARSE
 386         bool "Enable sparse check during kernel build"
 387         default n
 388
 389 config KERNEL_DEVTMPFS
 390         bool "Compile the kernel with device tmpfs enabled"
 391         default n
 392         help
 393           devtmpfs is a simple, kernel-managed /dev filesystem. The kernel creates
 394           devices nodes for all registered devices to simplify boot, but leaves more
 395           complex tasks to userspace (e.g. udev).
 396
 397 if KERNEL_DEVTMPFS
 398
 399         config KERNEL_DEVTMPFS_MOUNT
 400                 bool "Automatically mount devtmpfs after root filesystem is mounted"
 401                 default n
 402
 403 endif
 404
 405 config KERNEL_KEYS
 406     bool "Enable kernel access key retention support"
 407     default n
 408
 409 config KERNEL_PERSISTENT_KEYRINGS
 410     bool "Enable kernel persistent keyrings"
 411     depends on KERNEL_KEYS
 412     default n
 413
 414 config KERNEL_BIG_KEYS
 415     bool "Enable large payload keys on kernel keyrings"
 416     depends on KERNEL_KEYS
 417     default n
 418
 419 config KERNEL_ENCRYPTED_KEYS
 420     tristate "Enable keys with encrypted payloads on kernel keyrings"
 421     depends on KERNEL_KEYS
 422     default n
 423
 424 #
 425 # CGROUP support symbols
 426 #
 427
 428 config KERNEL_CGROUPS
 429         bool "Enable kernel cgroups"
 430         default y if !SMALL_FLASH
 431
 432 if KERNEL_CGROUPS
 433
 434         config KERNEL_CGROUP_DEBUG
 435                 bool "Example debug cgroup subsystem"
 436                 default n
 437                 help
 438                   This option enables a simple cgroup subsystem that
 439                   exports useful debugging information about the cgroups
 440                   framework.
 441
 442         config KERNEL_FREEZER
 443                 bool
 444                 default y if KERNEL_CGROUP_FREEZER
 445
 446         config KERNEL_CGROUP_FREEZER
 447                 bool "Freezer cgroup subsystem"
 448                 default y
 449                 help
 450                   Provides a way to freeze and unfreeze all tasks in a
 451                   cgroup.
 452
 453         config KERNEL_CGROUP_DEVICE
 454                 bool "Device controller for cgroups"
 455                 default y
 456                 help
 457                   Provides a cgroup implementing whitelists for devices which
 458                   a process in the cgroup can mknod or open.
 459
 460         config KERNEL_CGROUP_PIDS
 461                 bool "PIDs cgroup subsystem"
 462                 default y
 463                 help
 464                   Provides enforcement of process number limits in the scope of a
 465                   cgroup.
 466
 467         config KERNEL_CPUSETS
 468                 bool "Cpuset support"
 469                 default y if !SMALL_FLASH
 470                 help
 471                   This option will let you create and manage CPUSETs which
 472                   allow dynamically partitioning a system into sets of CPUs and
 473                   Memory Nodes and assigning tasks to run only within those sets.
 474                   This is primarily useful on large SMP or NUMA systems.
 475
 476         config KERNEL_PROC_PID_CPUSET
 477                 bool "Include legacy /proc/<pid>/cpuset file"
 478                 default n
 479                 depends on KERNEL_CPUSETS
 480
 481         config KERNEL_CGROUP_CPUACCT
 482                 bool "Simple CPU accounting cgroup subsystem"
 483                 default y if !SMALL_FLASH
 484                 help
 485                   Provides a simple Resource Controller for monitoring the
 486                   total CPU consumed by the tasks in a cgroup.
 487
 488         config KERNEL_RESOURCE_COUNTERS
 489                 bool "Resource counters"
 490                 default y if !SMALL_FLASH
 491                 help
 492                   This option enables controller independent resource accounting
 493                   infrastructure that works with cgroups.
 494
 495         config KERNEL_MM_OWNER
 496                 bool
 497                 default y if KERNEL_MEMCG
 498
 499         config KERNEL_MEMCG
 500                 bool "Memory Resource Controller for Control Groups"
 501                 default y if !SMALL_FLASH
 502                 depends on KERNEL_RESOURCE_COUNTERS || !LINUX_3_18
 503                 help
 504                   Provides a memory resource controller that manages both anonymous
 505                   memory and page cache. (See Documentation/cgroups/memory.txt)
 506
 507                   Note that setting this option increases fixed memory overhead
 508                   associated with each page of memory in the system. By this,
 509                   20(40)bytes/PAGE_SIZE on 32(64)bit system will be occupied by memory
 510                   usage tracking struct at boot. Total amount of this is printed out
 511                   at boot.
 512
 513                   Only enable when you're ok with these tradeoffs and really
 514                   sure you need the memory resource controller. Even when you enable
 515                   this, you can set "cgroup_disable=memory" at your boot option to
 516                   disable memory resource controller and you can avoid overheads
 517                   (but lose benefits of memory resource controller).
 518
 519                   This config option also selects MM_OWNER config option, which
 520                   could in turn add some fork/exit overhead.
 521
 522         config KERNEL_MEMCG_SWAP
 523                 bool "Memory Resource Controller Swap Extension"
 524                 default n
 525                 depends on KERNEL_MEMCG
 526                 help
 527                   Add swap management feature to memory resource controller. When you
 528                   enable this, you can limit mem+swap usage per cgroup. In other words,
 529                   when you disable this, memory resource controller has no cares to
 530                   usage of swap...a process can exhaust all of the swap. This extension
 531                   is useful when you want to avoid exhaustion swap but this itself
 532                   adds more overheads and consumes memory for remembering information.
 533                   Especially if you use 32bit system or small memory system, please
 534                   be careful about enabling this. When memory resource controller
 535                   is disabled by boot option, this will be automatically disabled and
 536                   there will be no overhead from this. Even when you set this config=y,
 537                   if boot option "swapaccount=0" is set, swap will not be accounted.
 538                   Now, memory usage of swap_cgroup is 2 bytes per entry. If swap page
 539                   size is 4096bytes, 512k per 1Gbytes of swap.
 540
 541         config KERNEL_MEMCG_SWAP_ENABLED
 542                 bool "Memory Resource Controller Swap Extension enabled by default"
 543                 default n
 544                 depends on KERNEL_MEMCG_SWAP
 545                 help
 546                   Memory Resource Controller Swap Extension comes with its price in
 547                   a bigger memory consumption. General purpose distribution kernels
 548                   which want to enable the feature but keep it disabled by default
 549                   and let the user enable it by swapaccount boot command line
 550                   parameter should have this option unselected.
 551
 552                   Those who want to have the feature enabled by default should
 553                   select this option (if, for some reason, they need to disable it,
 554                   then swapaccount=0 does the trick).
 555
 556
 557         config KERNEL_MEMCG_KMEM
 558                 bool "Memory Resource Controller Kernel Memory accounting (EXPERIMENTAL)"
 559                 default y if !SMALL_FLASH
 560                 depends on KERNEL_MEMCG
 561                 help
 562                   The Kernel Memory extension for Memory Resource Controller can limit
 563                   the amount of memory used by kernel objects in the system. Those are
 564                   fundamentally different from the entities handled by the standard
 565                   Memory Controller, which are page-based, and can be swapped. Users of
 566                   the kmem extension can use it to guarantee that no group of processes
 567                   will ever exhaust kernel resources alone.
 568
 569         config KERNEL_CGROUP_PERF
 570                 bool "Enable perf_event per-cpu per-container group (cgroup) monitoring"
 571                 select KERNEL_PERF_EVENTS
 572                 default n
 573                 help
 574                   This option extends the per-cpu mode to restrict monitoring to
 575                   threads which belong to the cgroup specified and run on the
 576                   designated cpu.
 577
 578         menuconfig KERNEL_CGROUP_SCHED
 579                 bool "Group CPU scheduler"
 580                 default y if !SMALL_FLASH
 581                 help
 582                   This feature lets CPU scheduler recognize task groups and control CPU
 583                   bandwidth allocation to such task groups. It uses cgroups to group
 584                   tasks.
 585
 586         if KERNEL_CGROUP_SCHED
 587
 588                 config KERNEL_FAIR_GROUP_SCHED
 589                         bool "Group scheduling for SCHED_OTHER"
 590                         default y if !SMALL_FLASH
 591
 592                 config KERNEL_CFS_BANDWIDTH
 593                         bool "CPU bandwidth provisioning for FAIR_GROUP_SCHED"
 594                         default n
 595                         depends on KERNEL_FAIR_GROUP_SCHED
 596                         help
 597                           This option allows users to define CPU bandwidth rates (limits) for
 598                           tasks running within the fair group scheduler.  Groups with no limit
 599                           set are considered to be unconstrained and will run with no
 600                           restriction.
 601                           See tip/Documentation/scheduler/sched-bwc.txt for more information.
 602
 603                 config KERNEL_RT_GROUP_SCHED
 604                         bool "Group scheduling for SCHED_RR/FIFO"
 605                         default y if !SMALL_FLASH
 606                         help
 607                           This feature lets you explicitly allocate real CPU bandwidth
 608                           to task groups. If enabled, it will also make it impossible to
 609                           schedule realtime tasks for non-root users until you allocate
 610                           realtime bandwidth for them.
 611
 612         endif
 613
 614         config KERNEL_BLK_CGROUP
 615                 bool "Block IO controller"
 616                 default y
 617                 help
 618                   Generic block IO controller cgroup interface. This is the common
 619                   cgroup interface which should be used by various IO controlling
 620                   policies.
 621
 622                   Currently, CFQ IO scheduler uses it to recognize task groups and
 623                   control disk bandwidth allocation (proportional time slice allocation)
 624                   to such task groups. It is also used by bio throttling logic in
 625                   block layer to implement upper limit in IO rates on a device.
 626
 627                   This option only enables generic Block IO controller infrastructure.
 628                   One needs to also enable actual IO controlling logic/policy. For
 629                   enabling proportional weight division of disk bandwidth in CFQ, set
 630                   CONFIG_CFQ_GROUP_IOSCHED=y; for enabling throttling policy, set
 631                   CONFIG_BLK_DEV_THROTTLING=y.
 632
 633         if KERNEL_BLK_CGROUP
 634
 635                 config KERNEL_CFQ_GROUP_IOSCHED
 636                         bool "Proportional weight of disk bandwidth in CFQ"
 637
 638                 config KERNEL_BLK_DEV_THROTTLING
 639                         bool "Enable throttling policy"
 640                         default y if TARGET_bcm27xx
 641
 642                 config KERNEL_BLK_DEV_THROTTLING_LOW
 643                         bool "Block throttling .low limit interface support (EXPERIMENTAL)"
 644                         depends on KERNEL_BLK_DEV_THROTTLING
 645         endif
 646
 647         config KERNEL_DEBUG_BLK_CGROUP
 648                 bool "Enable Block IO controller debugging"
 649                 default n
 650                 depends on KERNEL_BLK_CGROUP
 651                 help
 652                   Enable some debugging help. Currently it exports additional stat
 653                   files in a cgroup which can be useful for debugging.
 654
 655         config KERNEL_NET_CLS_CGROUP
 656                 bool "Control Group Classifier"
 657                 default y
 658
 659         config KERNEL_NETPRIO_CGROUP
 660                 bool "Network priority cgroup"
 661                 default y
 662
 663 endif
 664
 665 #
 666 # Namespace support symbols
 667 #
 668
 669 config KERNEL_NAMESPACES
 670         bool "Enable kernel namespaces"
 671         default y if !SMALL_FLASH
 672
 673 if KERNEL_NAMESPACES
 674
 675         config KERNEL_UTS_NS
 676                 bool "UTS namespace"
 677                 default y
 678                 help
 679                   In this namespace, tasks see different info provided
 680                   with the uname() system call.
 681
 682         config KERNEL_IPC_NS
 683                 bool "IPC namespace"
 684                 default y
 685                 help
 686                   In this namespace, tasks work with IPC ids which correspond to
 687                   different IPC objects in different namespaces.
 688
 689         config KERNEL_USER_NS
 690                 bool "User namespace (EXPERIMENTAL)"
 691                 default y
 692                 help
 693                   This allows containers, i.e. vservers, to use user namespaces
 694                   to provide different user info for different servers.
 695
 696         config KERNEL_PID_NS
 697                 bool "PID Namespaces"
 698                 default y
 699                 help
 700                   Support process id namespaces. This allows having multiple
 701                   processes with the same pid as long as they are in different
 702                   pid namespaces. This is a building block of containers.
 703
 704         config KERNEL_NET_NS
 705                 bool "Network namespace"
 706                 default y
 707                 help
 708                   Allow user space to create what appear to be multiple instances
 709                   of the network stack.
 710
 711 endif
 712
 713 config KERNEL_DEVPTS_MULTIPLE_INSTANCES
 714         bool "Support multiple instances of devpts"
 715         default y if !SMALL_FLASH
 716         help
 717           Enable support for multiple instances of devpts filesystem.
 718           If you want to have isolated PTY namespaces (eg: in containers),
 719           say Y here. Otherwise, say N. If enabled, each mount of devpts
 720           filesystem with the '-o newinstance' option will create an
 721           independent PTY namespace.
 722
 723 config KERNEL_POSIX_MQUEUE
 724         bool "POSIX Message Queues"
 725         default y if !SMALL_FLASH
 726         help
 727           POSIX variant of message queues is a part of IPC. In POSIX message
 728           queues every message has a priority which decides about succession
 729           of receiving it by a process. If you want to compile and run
 730           programs written e.g. for Solaris with use of its POSIX message
 731           queues (functions mq_*) say Y here.
 732
 733           POSIX message queues are visible as a filesystem called 'mqueue'
 734           and can be mounted somewhere if you want to do filesystem
 735           operations on message queues.
 736
 737
 738 config KERNEL_SECCOMP_FILTER
 739         bool
 740         default y if !SMALL_FLASH
 741
 742 config KERNEL_SECCOMP
 743         bool "Enable seccomp support"
 744                 depends on !(TARGET_uml)
 745                 select KERNEL_SECCOMP_FILTER
 746                 default y if !SMALL_FLASH
 747                 help
 748                   Build kernel with support for seccomp.
 749
 750 #
 751 # IPv4 configuration
 752 #
 753
 754 config KERNEL_IP_MROUTE
 755         bool "Enable IPv4 multicast routing"
 756         default y
 757         help
 758           Multicast routing requires a multicast routing daemon in
 759           addition to kernel support.
 760
 761 #
 762 # IPv6 configuration
 763 #
 764
 765 config KERNEL_IPV6
 766         def_bool IPV6
 767
 768 if KERNEL_IPV6
 769
 770         config KERNEL_IPV6_MULTIPLE_TABLES
 771                 def_bool y
 772
 773         config KERNEL_IPV6_SUBTREES
 774                 def_bool y
 775
 776         config KERNEL_IPV6_MROUTE
 777                 bool "Enable IPv6 multicast routing"
 778                 default y
 779                 help
 780                   Multicast routing requires a multicast routing daemon in
 781                   addition to kernel support.
 782
 783         config KERNEL_IPV6_PIMSM_V2
 784                 def_bool n
 785
 786 endif
 787
 788 #
 789 # NFS related symbols
 790 #
 791 config KERNEL_IP_PNP
 792         bool "Compile the kernel with rootfs on NFS"
 793         help
 794            If you want to make your kernel boot off a NFS server as root
 795            filesystem, select Y here.
 796
 797 if KERNEL_IP_PNP
 798
 799         config KERNEL_IP_PNP_DHCP
 800                 def_bool y
 801
 802         config KERNEL_IP_PNP_BOOTP
 803                 def_bool n
 804
 805         config KERNEL_IP_PNP_RARP
 806                 def_bool n
 807
 808         config KERNEL_NFS_FS
 809                 def_bool y
 810
 811         config KERNEL_NFS_V2
 812                 def_bool y
 813
 814         config KERNEL_NFS_V3
 815                 def_bool y
 816
 817         config KERNEL_ROOT_NFS
 818                 def_bool y
 819
 820 endif
 821
 822 menu "Filesystem ACL and attr support options"
 823         config USE_FS_ACL_ATTR
 824                 bool "Use filesystem ACL and attr support by default"
 825                 default n
 826                 help
 827                   Make using ACLs (e.g. POSIX ACL, NFSv4 ACL) the default
 828                   for kernel and packages, except tmpfs, flash filesystems,
 829                   and old NFS.  Also enable userspace extended attribute support
 830                   by default.  (OpenWrt already has an expection it will be
 831                   present in the kernel).
 832
 833         config KERNEL_FS_POSIX_ACL
 834                 bool "Enable POSIX ACL support"
 835                 default y if USE_FS_ACL_ATTR
 836
 837         config KERNEL_BTRFS_FS_POSIX_ACL
 838                 bool "Enable POSIX ACL for BtrFS Filesystems"
 839                 select KERNEL_FS_POSIX_ACL
 840                 default y if USE_FS_ACL_ATTR
 841
 842         config KERNEL_EXT4_FS_POSIX_ACL
 843                 bool "Enable POSIX ACL for Ext4 Filesystems"
 844                 select KERNEL_FS_POSIX_ACL
 845                 default y if USE_FS_ACL_ATTR
 846
 847         config KERNEL_F2FS_FS_POSIX_ACL
 848                 bool "Enable POSIX ACL for F2FS Filesystems"
 849                 select KERNEL_FS_POSIX_ACL
 850                 default n
 851
 852         config KERNEL_JFFS2_FS_POSIX_ACL
 853                 bool "Enable POSIX ACL for JFFS2 Filesystems"
 854                 select KERNEL_FS_POSIX_ACL
 855                 default n
 856
 857         config KERNEL_TMPFS_POSIX_ACL
 858                 bool "Enable POSIX ACL for TMPFS Filesystems"
 859                 select KERNEL_FS_POSIX_ACL
 860                 default n
 861
 862         config KERNEL_CIFS_ACL
 863                 bool "Enable CIFS ACLs"
 864                 select KERNEL_FS_POSIX_ACL
 865                 default y if USE_FS_ACL_ATTR
 866
 867         config KERNEL_HFS_FS_POSIX_ACL
 868                 bool "Enable POSIX ACL for HFS Filesystems"
 869                 select KERNEL_FS_POSIX_ACL
 870                 default y if USE_FS_ACL_ATTR
 871
 872         config KERNEL_HFSPLUS_FS_POSIX_ACL
 873                 bool "Enable POSIX ACL for HFS+ Filesystems"
 874                 select KERNEL_FS_POSIX_ACL
 875                 default y if USE_FS_ACL_ATTR
 876
 877         config KERNEL_NFS_ACL_SUPPORT
 878                 bool "Enable ACLs for NFS"
 879                 default y if USE_FS_ACL_ATTR
 880
 881         config KERNEL_NFS_V3_ACL_SUPPORT
 882                 bool "Enable ACLs for NFSv3"
 883                 default n
 884
 885         config KERNEL_NFSD_V2_ACL_SUPPORT
 886                 bool "Enable ACLs for NFSDv2"
 887                 default n
 888
 889         config KERNEL_NFSD_V3_ACL_SUPPORT
 890                 bool "Enable ACLs for NFSDv3"
 891                 default n
 892
 893         config KERNEL_REISER_FS_POSIX_ACL
 894                 bool "Enable POSIX ACLs for ReiserFS"
 895                 select KERNEL_FS_POSIX_ACL
 896                 default y if USE_FS_ACL_ATTR
 897
 898         config KERNEL_XFS_POSIX_ACL
 899                 bool "Enable POSIX ACLs for XFS"
 900                 select KERNEL_FS_POSIX_ACL
 901                 default y if USE_FS_ACL_ATTR
 902
 903         config KERNEL_JFS_POSIX_ACL
 904                 bool "Enable POSIX ACLs for JFS"
 905                 select KERNEL_FS_POSIX_ACL
 906                 default y if USE_FS_ACL_ATTR
 907
 908 endmenu
 909
 910 config KERNEL_DEVMEM
 911         bool "/dev/mem virtual device support"
 912         help
 913           Say Y here if you want to support the /dev/mem device.
 914           The /dev/mem device is used to access areas of physical
 915           memory.
 916
 917 config KERNEL_DEVKMEM
 918         bool "/dev/kmem virtual device support"
 919         help
 920           Say Y here if you want to support the /dev/kmem device. The
 921           /dev/kmem device is rarely used, but can be used for certain
 922           kind of kernel debugging operations.
 923
 924 config KERNEL_SQUASHFS_FRAGMENT_CACHE_SIZE
 925         int "Number of squashfs fragments cached"
 926         default 2 if (SMALL_FLASH && !LOW_MEMORY_FOOTPRINT)
 927         default 3
 928
 929 #
 930 # compile optimiziation setting
 931 #
 932 choice
 933         prompt "Compiler optimization level"
 934         default KERNEL_CC_OPTIMIZE_FOR_SIZE if SMALL_FLASH
 935
 936 config KERNEL_CC_OPTIMIZE_FOR_PERFORMANCE
 937         bool "Optimize for performance"
 938         help
 939           This is the default optimization level for the kernel, building
 940           with the "-O2" compiler flag for best performance and most
 941           helpful compile-time warnings.
 942
 943 config KERNEL_CC_OPTIMIZE_FOR_SIZE
 944         bool "Optimize for size"
 945         help
 946           Enabling this option will pass "-Os" instead of "-O2" to
 947           your compiler resulting in a smaller kernel.
 948
 949 endchoice