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