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