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