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