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         if KERNEL_BLK_CGROUP
 523
 524                 config KERNEL_CFQ_GROUP_IOSCHED
 525                         bool "Proportional weight of disk bandwidth in CFQ"
 526
 527                 config KERNEL_BLK_DEV_THROTTLING
 528                         bool "Enable throttling policy"
 529                         default y if TARGET_brcm2708
 530
 531                 config KERNEL_BLK_DEV_THROTTLING_LOW
 532                         bool "Block throttling .low limit interface support (EXPERIMENTAL)"
 533                         depends on KERNEL_BLK_DEV_THROTTLING
 534         endif
 535
 536         config KERNEL_DEBUG_BLK_CGROUP
 537                 bool "Enable Block IO controller debugging"
 538                 default n
 539                 depends on KERNEL_BLK_CGROUP
 540                 help
 541                   Enable some debugging help. Currently it exports additional stat
 542                   files in a cgroup which can be useful for debugging.
 543
 544         config KERNEL_NET_CLS_CGROUP
 545                 bool "Control Group Classifier"
 546                 default y
 547
 548         config KERNEL_NETPRIO_CGROUP
 549                 bool "Network priority cgroup"
 550                 default y
 551
 552 endif
 553
 554 #
 555 # Namespace support symbols
 556 #
 557
 558 config KERNEL_NAMESPACES
 559         bool "Enable kernel namespaces"
 560         default n
 561
 562 if KERNEL_NAMESPACES
 563
 564         config KERNEL_UTS_NS
 565                 bool "UTS namespace"
 566                 default y
 567                 help
 568                   In this namespace, tasks see different info provided
 569                   with the uname() system call.
 570
 571         config KERNEL_IPC_NS
 572                 bool "IPC namespace"
 573                 default y
 574                 help
 575                   In this namespace, tasks work with IPC ids which correspond to
 576                   different IPC objects in different namespaces.
 577
 578         config KERNEL_USER_NS
 579                 bool "User namespace (EXPERIMENTAL)"
 580                 default y
 581                 help
 582                   This allows containers, i.e. vservers, to use user namespaces
 583                   to provide different user info for different servers.
 584
 585         config KERNEL_PID_NS
 586                 bool "PID Namespaces"
 587                 default y
 588                 help
 589                   Support process id namespaces. This allows having multiple
 590                   processes with the same pid as long as they are in different
 591                   pid namespaces. This is a building block of containers.
 592
 593         config KERNEL_NET_NS
 594                 bool "Network namespace"
 595                 default y
 596                 help
 597                   Allow user space to create what appear to be multiple instances
 598                   of the network stack.
 599
 600 endif
 601
 602 #
 603 # LXC related symbols
 604 #
 605
 606 config KERNEL_LXC_MISC
 607         bool "Enable miscellaneous LXC related options"
 608         default n
 609
 610 if KERNEL_LXC_MISC
 611
 612         config KERNEL_DEVPTS_MULTIPLE_INSTANCES
 613                 bool "Support multiple instances of devpts"
 614                 default y
 615                 help
 616                   Enable support for multiple instances of devpts filesystem.
 617                   If you want to have isolated PTY namespaces (eg: in containers),
 618                   say Y here. Otherwise, say N. If enabled, each mount of devpts
 619                   filesystem with the '-o newinstance' option will create an
 620                   independent PTY namespace.
 621
 622         config KERNEL_POSIX_MQUEUE
 623                 bool "POSIX Message Queues"
 624                 default y
 625                 help
 626                   POSIX variant of message queues is a part of IPC. In POSIX message
 627                   queues every message has a priority which decides about succession
 628                   of receiving it by a process. If you want to compile and run
 629                   programs written e.g. for Solaris with use of its POSIX message
 630                   queues (functions mq_*) say Y here.
 631
 632                   POSIX message queues are visible as a filesystem called 'mqueue'
 633                   and can be mounted somewhere if you want to do filesystem
 634                   operations on message queues.
 635
 636 endif
 637
 638 config KERNEL_SECCOMP_FILTER
 639         bool
 640         default n
 641
 642 config KERNEL_SECCOMP
 643         bool "Enable seccomp support"
 644                 depends on !(TARGET_uml)
 645                 select KERNEL_SECCOMP_FILTER
 646                 default n
 647                 help
 648                   Build kernel with support for seccomp.
 649
 650 #
 651 # IPv4 configuration
 652 #
 653
 654 config KERNEL_IP_MROUTE
 655         bool "Enable IPv4 multicast routing"
 656         default y
 657         help
 658           Multicast routing requires a multicast routing daemon in
 659           addition to kernel support.
 660
 661 #
 662 # IPv6 configuration
 663 #
 664
 665 config KERNEL_IPV6
 666         def_bool IPV6
 667
 668 if KERNEL_IPV6
 669
 670         config KERNEL_IPV6_MULTIPLE_TABLES
 671                 def_bool y
 672
 673         config KERNEL_IPV6_SUBTREES
 674                 def_bool y
 675
 676         config KERNEL_IPV6_MROUTE
 677                 bool "Enable IPv6 multicast routing"
 678                 default y
 679                 help
 680                   Multicast routing requires a multicast routing daemon in
 681                   addition to kernel support.
 682
 683         config KERNEL_IPV6_PIMSM_V2
 684                 def_bool n
 685
 686 endif
 687
 688 #
 689 # NFS related symbols
 690 #
 691 config KERNEL_IP_PNP
 692         bool "Compile the kernel with rootfs on NFS"
 693         help
 694            If you want to make your kernel boot off a NFS server as root
 695            filesystem, select Y here.
 696
 697 if KERNEL_IP_PNP
 698
 699         config KERNEL_IP_PNP_DHCP
 700                 def_bool y
 701
 702         config KERNEL_IP_PNP_BOOTP
 703                 def_bool n
 704
 705         config KERNEL_IP_PNP_RARP
 706                 def_bool n
 707
 708         config KERNEL_NFS_FS
 709                 def_bool y
 710
 711         config KERNEL_NFS_V2
 712                 def_bool y
 713
 714         config KERNEL_NFS_V3
 715                 def_bool y
 716
 717         config KERNEL_ROOT_NFS
 718                 def_bool y
 719
 720 endif
 721
 722 menu "Filesystem ACL and attr support options"
 723         config USE_FS_ACL_ATTR
 724                 bool "Use filesystem ACL and attr support by default"
 725                 default n
 726                 help
 727                   Make using ACLs (e.g. POSIX ACL, NFSv4 ACL) the default
 728                   for kernel and packages, except tmpfs, flash filesystems,
 729                   and old NFS.  Also enable userspace extended attribute support
 730                   by default.  (OpenWrt already has an expection it will be
 731                   present in the kernel).
 732
 733         config KERNEL_FS_POSIX_ACL
 734                 bool "Enable POSIX ACL support"
 735                 default y if USE_FS_ACL_ATTR
 736
 737         config KERNEL_BTRFS_FS_POSIX_ACL
 738                 bool "Enable POSIX ACL for BtrFS Filesystems"
 739                 select KERNEL_FS_POSIX_ACL
 740                 default y if USE_FS_ACL_ATTR
 741
 742         config KERNEL_EXT4_FS_POSIX_ACL
 743                 bool "Enable POSIX ACL for Ext4 Filesystems"
 744                 select KERNEL_FS_POSIX_ACL
 745                 default y if USE_FS_ACL_ATTR
 746
 747         config KERNEL_F2FS_FS_POSIX_ACL
 748                 bool "Enable POSIX ACL for F2FS Filesystems"
 749                 select KERNEL_FS_POSIX_ACL
 750                 default n
 751
 752         config KERNEL_JFFS2_FS_POSIX_ACL
 753                 bool "Enable POSIX ACL for JFFS2 Filesystems"
 754                 select KERNEL_FS_POSIX_ACL
 755                 default n
 756
 757         config KERNEL_TMPFS_POSIX_ACL
 758                 bool "Enable POSIX ACL for TMPFS Filesystems"
 759                 select KERNEL_FS_POSIX_ACL
 760                 default n
 761
 762         config KERNEL_CIFS_ACL
 763                 bool "Enable CIFS ACLs"
 764                 select KERNEL_FS_POSIX_ACL
 765                 default y if USE_FS_ACL_ATTR
 766
 767         config KERNEL_HFS_FS_POSIX_ACL
 768                 bool "Enable POSIX ACL for HFS Filesystems"
 769                 select KERNEL_FS_POSIX_ACL
 770                 default y if USE_FS_ACL_ATTR
 771
 772         config KERNEL_HFSPLUG_FS_POSIX_ACL
 773                 bool "Enable POSIX ACL for HFS+ Filesystems"
 774                 select KERNEL_FS_POSIX_ACL
 775                 default y if USE_FS_ACL_ATTR
 776
 777         config KERNEL_NFS_ACL_SUPPORT
 778                 bool "Enable ACLs for NFS"
 779                 default y if USE_FS_ACL_ATTR
 780
 781         config KERNEL_NFS_V3_ACL_SUPPORT
 782                 bool "Enable ACLs for NFSv3"
 783                 default n
 784
 785         config KERNEL_NFSD_V2_ACL_SUPPORT
 786                 bool "Enable ACLs for NFSDv2"
 787                 default n
 788
 789         config KERNEL_NFSD_V3_ACL_SUPPORT
 790                 bool "Enable ACLs for NFSDv3"
 791                 default n
 792
 793         config KERNEL_REISER_FS_POSIX_ACL
 794                 bool "Enable POSIX ACLs for ReiserFS"
 795                 select KERNEL_FS_POSIX_ACL
 796                 default y if USE_FS_ACL_ATTR
 797
 798         config KERNEL_XFS_POSIX_ACL
 799                 bool "Enable POSIX ACLs for XFS"
 800                 select KERNEL_FS_POSIX_ACL
 801                 default y if USE_FS_ACL_ATTR
 802
 803         config KERNEL_JFS_POSIX_ACL
 804                 bool "Enable POSIX ACLs for JFS"
 805                 select KERNEL_FS_POSIX_ACL
 806                 default y if USE_FS_ACL_ATTR
 807
 808 endmenu
 809
 810 config KERNEL_DEVMEM
 811         bool "/dev/mem virtual device support"
 812         help
 813           Say Y here if you want to support the /dev/mem device.
 814           The /dev/mem device is used to access areas of physical
 815           memory.
 816
 817 config KERNEL_DEVKMEM
 818         bool "/dev/kmem virtual device support"
 819         help
 820           Say Y here if you want to support the /dev/kmem device. The
 821           /dev/kmem device is rarely used, but can be used for certain
 822           kind of kernel debugging operations.
 823
 824 config KERNEL_SQUASHFS_FRAGMENT_CACHE_SIZE
 825         int "Number of squashfs fragments cached"
 826         default 2 if (SMALL_FLASH && !LOW_MEMORY_FOOTPRINT)
 827         default 3
 828
 829 #
 830 # compile optimiziation setting
 831 #
 832 choice
 833         prompt "Compiler optimization level"
 834         default KERNEL_CC_OPTIMIZE_FOR_SIZE if SMALL_FLASH
 835
 836 config KERNEL_CC_OPTIMIZE_FOR_PERFORMANCE
 837         bool "Optimize for performance"
 838         help
 839           This is the default optimization level for the kernel, building
 840           with the "-O2" compiler flag for best performance and most
 841           helpful compile-time warnings.
 842
 843 config KERNEL_CC_OPTIMIZE_FOR_SIZE
 844         bool "Optimize for size"
 845         help
 846           Enabling this option will pass "-Os" instead of "-O2" to
 847           your compiler resulting in a smaller kernel.
 848
 849 endchoice