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