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