1# SPDX-License-Identifier: GPL-2.0-only 2config DEFCONFIG_LIST 3 string 4 depends on !UML 5 option defconfig_list 6 default "/lib/modules/$(shell,uname -r)/.config" 7 default "/etc/kernel-config" 8 default "/boot/config-$(shell,uname -r)" 9 default "arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG)" 10 11config CC_VERSION_TEXT 12 string 13 default "$(CC_VERSION_TEXT)" 14 help 15 This is used in unclear ways: 16 17 - Re-run Kconfig when the compiler is updated 18 The 'default' property references the environment variable, 19 CC_VERSION_TEXT so it is recorded in include/config/auto.conf.cmd. 20 When the compiler is updated, Kconfig will be invoked. 21 22 - Ensure full rebuild when the compier is updated 23 include/linux/kconfig.h contains this option in the comment line so 24 fixdep adds include/config/cc/version/text.h into the auto-generated 25 dependency. When the compiler is updated, syncconfig will touch it 26 and then every file will be rebuilt. 27 28config CC_IS_GCC 29 def_bool $(success,echo "$(CC_VERSION_TEXT)" | grep -q gcc) 30 31config GCC_VERSION 32 int 33 default $(shell,$(srctree)/scripts/gcc-version.sh $(CC)) if CC_IS_GCC 34 default 0 35 36config LD_VERSION 37 int 38 default $(shell,$(LD) --version | $(srctree)/scripts/ld-version.sh) 39 40config CC_IS_CLANG 41 def_bool $(success,echo "$(CC_VERSION_TEXT)" | grep -q clang) 42 43config LD_IS_LLD 44 def_bool $(success,$(LD) -v | head -n 1 | grep -q LLD) 45 46config CLANG_VERSION 47 int 48 default $(shell,$(srctree)/scripts/clang-version.sh $(CC)) 49 50config LLD_VERSION 51 int 52 default $(shell,$(srctree)/scripts/lld-version.sh $(LD)) 53 54config CC_CAN_LINK 55 bool 56 default $(success,$(srctree)/scripts/cc-can-link.sh $(CC) $(CLANG_FLAGS) $(m64-flag)) if 64BIT 57 default $(success,$(srctree)/scripts/cc-can-link.sh $(CC) $(CLANG_FLAGS) $(m32-flag)) 58 59config CC_CAN_LINK_STATIC 60 bool 61 default $(success,$(srctree)/scripts/cc-can-link.sh $(CC) $(CLANG_FLAGS) $(m64-flag) -static) if 64BIT 62 default $(success,$(srctree)/scripts/cc-can-link.sh $(CC) $(CLANG_FLAGS) $(m32-flag) -static) 63 64config CC_HAS_ASM_GOTO 65 def_bool $(success,$(srctree)/scripts/gcc-goto.sh $(CC)) 66 67config CC_HAS_ASM_GOTO_OUTPUT 68 depends on CC_HAS_ASM_GOTO 69 def_bool $(success,echo 'int foo(int x) { asm goto ("": "=r"(x) ::: bar); return x; bar: return 0; }' | $(CC) -x c - -c -o /dev/null) 70 71config TOOLS_SUPPORT_RELR 72 def_bool $(success,env "CC=$(CC)" "LD=$(LD)" "NM=$(NM)" "OBJCOPY=$(OBJCOPY)" $(srctree)/scripts/tools-support-relr.sh) 73 74config CC_HAS_ASM_INLINE 75 def_bool $(success,echo 'void foo(void) { asm inline (""); }' | $(CC) -x c - -c -o /dev/null) 76 77config CONSTRUCTORS 78 bool 79 depends on !UML 80 81config IRQ_WORK 82 bool 83 84config BUILDTIME_TABLE_SORT 85 bool 86 87config THREAD_INFO_IN_TASK 88 bool 89 help 90 Select this to move thread_info off the stack into task_struct. To 91 make this work, an arch will need to remove all thread_info fields 92 except flags and fix any runtime bugs. 93 94 One subtle change that will be needed is to use try_get_task_stack() 95 and put_task_stack() in save_thread_stack_tsk() and get_wchan(). 96 97menu "General setup" 98 99config BROKEN 100 bool 101 102config BROKEN_ON_SMP 103 bool 104 depends on BROKEN || !SMP 105 default y 106 107config INIT_ENV_ARG_LIMIT 108 int 109 default 32 if !UML 110 default 128 if UML 111 help 112 Maximum of each of the number of arguments and environment 113 variables passed to init from the kernel command line. 114 115config COMPILE_TEST 116 bool "Compile also drivers which will not load" 117 depends on HAS_IOMEM 118 help 119 Some drivers can be compiled on a different platform than they are 120 intended to be run on. Despite they cannot be loaded there (or even 121 when they load they cannot be used due to missing HW support), 122 developers still, opposing to distributors, might want to build such 123 drivers to compile-test them. 124 125 If you are a developer and want to build everything available, say Y 126 here. If you are a user/distributor, say N here to exclude useless 127 drivers to be distributed. 128 129config UAPI_HEADER_TEST 130 bool "Compile test UAPI headers" 131 depends on HEADERS_INSTALL && CC_CAN_LINK 132 help 133 Compile test headers exported to user-space to ensure they are 134 self-contained, i.e. compilable as standalone units. 135 136 If you are a developer or tester and want to ensure the exported 137 headers are self-contained, say Y here. Otherwise, choose N. 138 139config LOCALVERSION 140 string "Local version - append to kernel release" 141 help 142 Append an extra string to the end of your kernel version. 143 This will show up when you type uname, for example. 144 The string you set here will be appended after the contents of 145 any files with a filename matching localversion* in your 146 object and source tree, in that order. Your total string can 147 be a maximum of 64 characters. 148 149config LOCALVERSION_AUTO 150 bool "Automatically append version information to the version string" 151 default y 152 depends on !COMPILE_TEST 153 help 154 This will try to automatically determine if the current tree is a 155 release tree by looking for git tags that belong to the current 156 top of tree revision. 157 158 A string of the format -gxxxxxxxx will be added to the localversion 159 if a git-based tree is found. The string generated by this will be 160 appended after any matching localversion* files, and after the value 161 set in CONFIG_LOCALVERSION. 162 163 (The actual string used here is the first eight characters produced 164 by running the command: 165 166 $ git rev-parse --verify HEAD 167 168 which is done within the script "scripts/setlocalversion".) 169 170config BUILD_SALT 171 string "Build ID Salt" 172 default "" 173 help 174 The build ID is used to link binaries and their debug info. Setting 175 this option will use the value in the calculation of the build id. 176 This is mostly useful for distributions which want to ensure the 177 build is unique between builds. It's safe to leave the default. 178 179config HAVE_KERNEL_GZIP 180 bool 181 182config HAVE_KERNEL_BZIP2 183 bool 184 185config HAVE_KERNEL_LZMA 186 bool 187 188config HAVE_KERNEL_XZ 189 bool 190 191config HAVE_KERNEL_LZO 192 bool 193 194config HAVE_KERNEL_LZ4 195 bool 196 197config HAVE_KERNEL_ZSTD 198 bool 199 200config HAVE_KERNEL_UNCOMPRESSED 201 bool 202 203choice 204 prompt "Kernel compression mode" 205 default KERNEL_GZIP 206 depends on HAVE_KERNEL_GZIP || HAVE_KERNEL_BZIP2 || HAVE_KERNEL_LZMA || HAVE_KERNEL_XZ || HAVE_KERNEL_LZO || HAVE_KERNEL_LZ4 || HAVE_KERNEL_ZSTD || HAVE_KERNEL_UNCOMPRESSED 207 help 208 The linux kernel is a kind of self-extracting executable. 209 Several compression algorithms are available, which differ 210 in efficiency, compression and decompression speed. 211 Compression speed is only relevant when building a kernel. 212 Decompression speed is relevant at each boot. 213 214 If you have any problems with bzip2 or lzma compressed 215 kernels, mail me (Alain Knaff) <alain@knaff.lu>. (An older 216 version of this functionality (bzip2 only), for 2.4, was 217 supplied by Christian Ludwig) 218 219 High compression options are mostly useful for users, who 220 are low on disk space (embedded systems), but for whom ram 221 size matters less. 222 223 If in doubt, select 'gzip' 224 225config KERNEL_GZIP 226 bool "Gzip" 227 depends on HAVE_KERNEL_GZIP 228 help 229 The old and tried gzip compression. It provides a good balance 230 between compression ratio and decompression speed. 231 232config KERNEL_BZIP2 233 bool "Bzip2" 234 depends on HAVE_KERNEL_BZIP2 235 help 236 Its compression ratio and speed is intermediate. 237 Decompression speed is slowest among the choices. The kernel 238 size is about 10% smaller with bzip2, in comparison to gzip. 239 Bzip2 uses a large amount of memory. For modern kernels you 240 will need at least 8MB RAM or more for booting. 241 242config KERNEL_LZMA 243 bool "LZMA" 244 depends on HAVE_KERNEL_LZMA 245 help 246 This compression algorithm's ratio is best. Decompression speed 247 is between gzip and bzip2. Compression is slowest. 248 The kernel size is about 33% smaller with LZMA in comparison to gzip. 249 250config KERNEL_XZ 251 bool "XZ" 252 depends on HAVE_KERNEL_XZ 253 help 254 XZ uses the LZMA2 algorithm and instruction set specific 255 BCJ filters which can improve compression ratio of executable 256 code. The size of the kernel is about 30% smaller with XZ in 257 comparison to gzip. On architectures for which there is a BCJ 258 filter (i386, x86_64, ARM, IA-64, PowerPC, and SPARC), XZ 259 will create a few percent smaller kernel than plain LZMA. 260 261 The speed is about the same as with LZMA: The decompression 262 speed of XZ is better than that of bzip2 but worse than gzip 263 and LZO. Compression is slow. 264 265config KERNEL_LZO 266 bool "LZO" 267 depends on HAVE_KERNEL_LZO 268 help 269 Its compression ratio is the poorest among the choices. The kernel 270 size is about 10% bigger than gzip; however its speed 271 (both compression and decompression) is the fastest. 272 273config KERNEL_LZ4 274 bool "LZ4" 275 depends on HAVE_KERNEL_LZ4 276 help 277 LZ4 is an LZ77-type compressor with a fixed, byte-oriented encoding. 278 A preliminary version of LZ4 de/compression tool is available at 279 <https://code.google.com/p/lz4/>. 280 281 Its compression ratio is worse than LZO. The size of the kernel 282 is about 8% bigger than LZO. But the decompression speed is 283 faster than LZO. 284 285config KERNEL_ZSTD 286 bool "ZSTD" 287 depends on HAVE_KERNEL_ZSTD 288 help 289 ZSTD is a compression algorithm targeting intermediate compression 290 with fast decompression speed. It will compress better than GZIP and 291 decompress around the same speed as LZO, but slower than LZ4. You 292 will need at least 192 KB RAM or more for booting. The zstd command 293 line tool is required for compression. 294 295config KERNEL_UNCOMPRESSED 296 bool "None" 297 depends on HAVE_KERNEL_UNCOMPRESSED 298 help 299 Produce uncompressed kernel image. This option is usually not what 300 you want. It is useful for debugging the kernel in slow simulation 301 environments, where decompressing and moving the kernel is awfully 302 slow. This option allows early boot code to skip the decompressor 303 and jump right at uncompressed kernel image. 304 305endchoice 306 307config DEFAULT_INIT 308 string "Default init path" 309 default "" 310 help 311 This option determines the default init for the system if no init= 312 option is passed on the kernel command line. If the requested path is 313 not present, we will still then move on to attempting further 314 locations (e.g. /sbin/init, etc). If this is empty, we will just use 315 the fallback list when init= is not passed. 316 317config DEFAULT_HOSTNAME 318 string "Default hostname" 319 default "(none)" 320 help 321 This option determines the default system hostname before userspace 322 calls sethostname(2). The kernel traditionally uses "(none)" here, 323 but you may wish to use a different default here to make a minimal 324 system more usable with less configuration. 325 326# 327# For some reason microblaze and nios2 hard code SWAP=n. Hopefully we can 328# add proper SWAP support to them, in which case this can be remove. 329# 330config ARCH_NO_SWAP 331 bool 332 333config SWAP 334 bool "Support for paging of anonymous memory (swap)" 335 depends on MMU && BLOCK && !ARCH_NO_SWAP 336 default y 337 help 338 This option allows you to choose whether you want to have support 339 for so called swap devices or swap files in your kernel that are 340 used to provide more virtual memory than the actual RAM present 341 in your computer. If unsure say Y. 342 343config SYSVIPC 344 bool "System V IPC" 345 help 346 Inter Process Communication is a suite of library functions and 347 system calls which let processes (running programs) synchronize and 348 exchange information. It is generally considered to be a good thing, 349 and some programs won't run unless you say Y here. In particular, if 350 you want to run the DOS emulator dosemu under Linux (read the 351 DOSEMU-HOWTO, available from <http://www.tldp.org/docs.html#howto>), 352 you'll need to say Y here. 353 354 You can find documentation about IPC with "info ipc" and also in 355 section 6.4 of the Linux Programmer's Guide, available from 356 <http://www.tldp.org/guides.html>. 357 358config SYSVIPC_SYSCTL 359 bool 360 depends on SYSVIPC 361 depends on SYSCTL 362 default y 363 364config POSIX_MQUEUE 365 bool "POSIX Message Queues" 366 depends on NET 367 help 368 POSIX variant of message queues is a part of IPC. In POSIX message 369 queues every message has a priority which decides about succession 370 of receiving it by a process. If you want to compile and run 371 programs written e.g. for Solaris with use of its POSIX message 372 queues (functions mq_*) say Y here. 373 374 POSIX message queues are visible as a filesystem called 'mqueue' 375 and can be mounted somewhere if you want to do filesystem 376 operations on message queues. 377 378 If unsure, say Y. 379 380config POSIX_MQUEUE_SYSCTL 381 bool 382 depends on POSIX_MQUEUE 383 depends on SYSCTL 384 default y 385 386config WATCH_QUEUE 387 bool "General notification queue" 388 default n 389 help 390 391 This is a general notification queue for the kernel to pass events to 392 userspace by splicing them into pipes. It can be used in conjunction 393 with watches for key/keyring change notifications and device 394 notifications. 395 396 See Documentation/watch_queue.rst 397 398config CROSS_MEMORY_ATTACH 399 bool "Enable process_vm_readv/writev syscalls" 400 depends on MMU 401 default y 402 help 403 Enabling this option adds the system calls process_vm_readv and 404 process_vm_writev which allow a process with the correct privileges 405 to directly read from or write to another process' address space. 406 See the man page for more details. 407 408config USELIB 409 bool "uselib syscall" 410 def_bool ALPHA || M68K || SPARC || X86_32 || IA32_EMULATION 411 help 412 This option enables the uselib syscall, a system call used in the 413 dynamic linker from libc5 and earlier. glibc does not use this 414 system call. If you intend to run programs built on libc5 or 415 earlier, you may need to enable this syscall. Current systems 416 running glibc can safely disable this. 417 418config AUDIT 419 bool "Auditing support" 420 depends on NET 421 help 422 Enable auditing infrastructure that can be used with another 423 kernel subsystem, such as SELinux (which requires this for 424 logging of avc messages output). System call auditing is included 425 on architectures which support it. 426 427config HAVE_ARCH_AUDITSYSCALL 428 bool 429 430config AUDITSYSCALL 431 def_bool y 432 depends on AUDIT && HAVE_ARCH_AUDITSYSCALL 433 select FSNOTIFY 434 435source "kernel/irq/Kconfig" 436source "kernel/time/Kconfig" 437source "kernel/Kconfig.preempt" 438 439menu "CPU/Task time and stats accounting" 440 441config VIRT_CPU_ACCOUNTING 442 bool 443 444choice 445 prompt "Cputime accounting" 446 default TICK_CPU_ACCOUNTING if !PPC64 447 default VIRT_CPU_ACCOUNTING_NATIVE if PPC64 448 449# Kind of a stub config for the pure tick based cputime accounting 450config TICK_CPU_ACCOUNTING 451 bool "Simple tick based cputime accounting" 452 depends on !S390 && !NO_HZ_FULL 453 help 454 This is the basic tick based cputime accounting that maintains 455 statistics about user, system and idle time spent on per jiffies 456 granularity. 457 458 If unsure, say Y. 459 460config VIRT_CPU_ACCOUNTING_NATIVE 461 bool "Deterministic task and CPU time accounting" 462 depends on HAVE_VIRT_CPU_ACCOUNTING && !NO_HZ_FULL 463 select VIRT_CPU_ACCOUNTING 464 help 465 Select this option to enable more accurate task and CPU time 466 accounting. This is done by reading a CPU counter on each 467 kernel entry and exit and on transitions within the kernel 468 between system, softirq and hardirq state, so there is a 469 small performance impact. In the case of s390 or IBM POWER > 5, 470 this also enables accounting of stolen time on logically-partitioned 471 systems. 472 473config VIRT_CPU_ACCOUNTING_GEN 474 bool "Full dynticks CPU time accounting" 475 depends on HAVE_CONTEXT_TRACKING 476 depends on HAVE_VIRT_CPU_ACCOUNTING_GEN 477 depends on GENERIC_CLOCKEVENTS 478 select VIRT_CPU_ACCOUNTING 479 select CONTEXT_TRACKING 480 help 481 Select this option to enable task and CPU time accounting on full 482 dynticks systems. This accounting is implemented by watching every 483 kernel-user boundaries using the context tracking subsystem. 484 The accounting is thus performed at the expense of some significant 485 overhead. 486 487 For now this is only useful if you are working on the full 488 dynticks subsystem development. 489 490 If unsure, say N. 491 492endchoice 493 494config IRQ_TIME_ACCOUNTING 495 bool "Fine granularity task level IRQ time accounting" 496 depends on HAVE_IRQ_TIME_ACCOUNTING && !VIRT_CPU_ACCOUNTING_NATIVE 497 help 498 Select this option to enable fine granularity task irq time 499 accounting. This is done by reading a timestamp on each 500 transitions between softirq and hardirq state, so there can be a 501 small performance impact. 502 503 If in doubt, say N here. 504 505config HAVE_SCHED_AVG_IRQ 506 def_bool y 507 depends on IRQ_TIME_ACCOUNTING || PARAVIRT_TIME_ACCOUNTING 508 depends on SMP 509 510config SCHED_THERMAL_PRESSURE 511 bool 512 default y if ARM && ARM_CPU_TOPOLOGY 513 default y if ARM64 514 depends on SMP 515 depends on CPU_FREQ_THERMAL 516 help 517 Select this option to enable thermal pressure accounting in the 518 scheduler. Thermal pressure is the value conveyed to the scheduler 519 that reflects the reduction in CPU compute capacity resulted from 520 thermal throttling. Thermal throttling occurs when the performance of 521 a CPU is capped due to high operating temperatures. 522 523 If selected, the scheduler will be able to balance tasks accordingly, 524 i.e. put less load on throttled CPUs than on non/less throttled ones. 525 526 This requires the architecture to implement 527 arch_set_thermal_pressure() and arch_get_thermal_pressure(). 528 529config SCHED_WALT 530 bool "Support window based load tracking" 531 depends on SMP 532 help 533 This feature will allow the scheduler to maintain a tunable window 534 based set of metrics for tasks and runqueues. These metrics can be 535 used to guide task placement as well as task frequency requirements 536 for cpufreq governors. 537 538config BSD_PROCESS_ACCT 539 bool "BSD Process Accounting" 540 depends on MULTIUSER 541 help 542 If you say Y here, a user level program will be able to instruct the 543 kernel (via a special system call) to write process accounting 544 information to a file: whenever a process exits, information about 545 that process will be appended to the file by the kernel. The 546 information includes things such as creation time, owning user, 547 command name, memory usage, controlling terminal etc. (the complete 548 list is in the struct acct in <file:include/linux/acct.h>). It is 549 up to the user level program to do useful things with this 550 information. This is generally a good idea, so say Y. 551 552config BSD_PROCESS_ACCT_V3 553 bool "BSD Process Accounting version 3 file format" 554 depends on BSD_PROCESS_ACCT 555 default n 556 help 557 If you say Y here, the process accounting information is written 558 in a new file format that also logs the process IDs of each 559 process and its parent. Note that this file format is incompatible 560 with previous v0/v1/v2 file formats, so you will need updated tools 561 for processing it. A preliminary version of these tools is available 562 at <http://www.gnu.org/software/acct/>. 563 564config TASKSTATS 565 bool "Export task/process statistics through netlink" 566 depends on NET 567 depends on MULTIUSER 568 default n 569 help 570 Export selected statistics for tasks/processes through the 571 generic netlink interface. Unlike BSD process accounting, the 572 statistics are available during the lifetime of tasks/processes as 573 responses to commands. Like BSD accounting, they are sent to user 574 space on task exit. 575 576 Say N if unsure. 577 578config TASK_DELAY_ACCT 579 bool "Enable per-task delay accounting" 580 depends on TASKSTATS 581 select SCHED_INFO 582 help 583 Collect information on time spent by a task waiting for system 584 resources like cpu, synchronous block I/O completion and swapping 585 in pages. Such statistics can help in setting a task's priorities 586 relative to other tasks for cpu, io, rss limits etc. 587 588 Say N if unsure. 589 590config TASK_XACCT 591 bool "Enable extended accounting over taskstats" 592 depends on TASKSTATS 593 help 594 Collect extended task accounting data and send the data 595 to userland for processing over the taskstats interface. 596 597 Say N if unsure. 598 599config TASK_IO_ACCOUNTING 600 bool "Enable per-task storage I/O accounting" 601 depends on TASK_XACCT 602 help 603 Collect information on the number of bytes of storage I/O which this 604 task has caused. 605 606 Say N if unsure. 607 608config PSI 609 bool "Pressure stall information tracking" 610 help 611 Collect metrics that indicate how overcommitted the CPU, memory, 612 and IO capacity are in the system. 613 614 If you say Y here, the kernel will create /proc/pressure/ with the 615 pressure statistics files cpu, memory, and io. These will indicate 616 the share of walltime in which some or all tasks in the system are 617 delayed due to contention of the respective resource. 618 619 In kernels with cgroup support, cgroups (cgroup2 only) will 620 have cpu.pressure, memory.pressure, and io.pressure files, 621 which aggregate pressure stalls for the grouped tasks only. 622 623 For more details see Documentation/accounting/psi.rst. 624 625 Say N if unsure. 626 627config PSI_DEFAULT_DISABLED 628 bool "Require boot parameter to enable pressure stall information tracking" 629 default n 630 depends on PSI 631 help 632 If set, pressure stall information tracking will be disabled 633 per default but can be enabled through passing psi=1 on the 634 kernel commandline during boot. 635 636 This feature adds some code to the task wakeup and sleep 637 paths of the scheduler. The overhead is too low to affect 638 common scheduling-intense workloads in practice (such as 639 webservers, memcache), but it does show up in artificial 640 scheduler stress tests, such as hackbench. 641 642 If you are paranoid and not sure what the kernel will be 643 used for, say Y. 644 645 Say N if unsure. 646 647endmenu # "CPU/Task time and stats accounting" 648 649config CPU_ISOLATION 650 bool "CPU isolation" 651 depends on SMP || COMPILE_TEST 652 default y 653 help 654 Make sure that CPUs running critical tasks are not disturbed by 655 any source of "noise" such as unbound workqueues, timers, kthreads... 656 Unbound jobs get offloaded to housekeeping CPUs. This is driven by 657 the "isolcpus=" boot parameter. 658 659 Say Y if unsure. 660 661config SCHED_RUNNING_AVG 662 bool "per-rq and per-cluster running average statistics" 663 default n 664 665config CPU_ISOLATION_OPT 666 bool "CPU isolation optimization" 667 depends on SMP 668 default n 669 help 670 This option enables cpu isolation optimization, which allows 671 to isolate cpu dynamically. The isolated cpu will be unavailable 672 to scheduler and load balancer, and all its non-pinned timers, 673 IRQs and tasks will be migrated to other cpus, only pinned 674 kthread and IRQS are still allowed to run, this achieves 675 similar effect as hotplug but at lower latency cost. 676 677config SCHED_CORE_CTRL 678 bool "Core control" 679 depends on CPU_ISOLATION_OPT 680 select SCHED_RUNNING_AVG 681 default n 682 help 683 This option enables the core control functionality in 684 the scheduler. Core control automatically isolate and 685 unisolate cores based on cpu load and utilization. 686 687source "kernel/rcu/Kconfig" 688 689config BUILD_BIN2C 690 bool 691 default n 692 693config IKCONFIG 694 tristate "Kernel .config support" 695 help 696 This option enables the complete Linux kernel ".config" file 697 contents to be saved in the kernel. It provides documentation 698 of which kernel options are used in a running kernel or in an 699 on-disk kernel. This information can be extracted from the kernel 700 image file with the script scripts/extract-ikconfig and used as 701 input to rebuild the current kernel or to build another kernel. 702 It can also be extracted from a running kernel by reading 703 /proc/config.gz if enabled (below). 704 705config IKCONFIG_PROC 706 bool "Enable access to .config through /proc/config.gz" 707 depends on IKCONFIG && PROC_FS 708 help 709 This option enables access to the kernel configuration file 710 through /proc/config.gz. 711 712config IKHEADERS 713 tristate "Enable kernel headers through /sys/kernel/kheaders.tar.xz" 714 depends on SYSFS 715 help 716 This option enables access to the in-kernel headers that are generated during 717 the build process. These can be used to build eBPF tracing programs, 718 or similar programs. If you build the headers as a module, a module called 719 kheaders.ko is built which can be loaded on-demand to get access to headers. 720 721config LOG_BUF_SHIFT 722 int "Kernel log buffer size (16 => 64KB, 17 => 128KB)" 723 range 12 25 if !H8300 724 range 12 19 if H8300 725 default 17 726 depends on PRINTK 727 help 728 Select the minimal kernel log buffer size as a power of 2. 729 The final size is affected by LOG_CPU_MAX_BUF_SHIFT config 730 parameter, see below. Any higher size also might be forced 731 by "log_buf_len" boot parameter. 732 733 Examples: 734 17 => 128 KB 735 16 => 64 KB 736 15 => 32 KB 737 14 => 16 KB 738 13 => 8 KB 739 12 => 4 KB 740 741config LOG_CPU_MAX_BUF_SHIFT 742 int "CPU kernel log buffer size contribution (13 => 8 KB, 17 => 128KB)" 743 depends on SMP 744 range 0 21 745 default 12 if !BASE_SMALL 746 default 0 if BASE_SMALL 747 depends on PRINTK 748 help 749 This option allows to increase the default ring buffer size 750 according to the number of CPUs. The value defines the contribution 751 of each CPU as a power of 2. The used space is typically only few 752 lines however it might be much more when problems are reported, 753 e.g. backtraces. 754 755 The increased size means that a new buffer has to be allocated and 756 the original static one is unused. It makes sense only on systems 757 with more CPUs. Therefore this value is used only when the sum of 758 contributions is greater than the half of the default kernel ring 759 buffer as defined by LOG_BUF_SHIFT. The default values are set 760 so that more than 16 CPUs are needed to trigger the allocation. 761 762 Also this option is ignored when "log_buf_len" kernel parameter is 763 used as it forces an exact (power of two) size of the ring buffer. 764 765 The number of possible CPUs is used for this computation ignoring 766 hotplugging making the computation optimal for the worst case 767 scenario while allowing a simple algorithm to be used from bootup. 768 769 Examples shift values and their meaning: 770 17 => 128 KB for each CPU 771 16 => 64 KB for each CPU 772 15 => 32 KB for each CPU 773 14 => 16 KB for each CPU 774 13 => 8 KB for each CPU 775 12 => 4 KB for each CPU 776 777config PRINTK_SAFE_LOG_BUF_SHIFT 778 int "Temporary per-CPU printk log buffer size (12 => 4KB, 13 => 8KB)" 779 range 10 21 780 default 13 781 depends on PRINTK 782 help 783 Select the size of an alternate printk per-CPU buffer where messages 784 printed from usafe contexts are temporary stored. One example would 785 be NMI messages, another one - printk recursion. The messages are 786 copied to the main log buffer in a safe context to avoid a deadlock. 787 The value defines the size as a power of 2. 788 789 Those messages are rare and limited. The largest one is when 790 a backtrace is printed. It usually fits into 4KB. Select 791 8KB if you want to be on the safe side. 792 793 Examples: 794 17 => 128 KB for each CPU 795 16 => 64 KB for each CPU 796 15 => 32 KB for each CPU 797 14 => 16 KB for each CPU 798 13 => 8 KB for each CPU 799 12 => 4 KB for each CPU 800 801# 802# Architectures with an unreliable sched_clock() should select this: 803# 804config HAVE_UNSTABLE_SCHED_CLOCK 805 bool 806 807config GENERIC_SCHED_CLOCK 808 bool 809 810menu "Scheduler features" 811 812config UCLAMP_TASK 813 bool "Enable utilization clamping for RT/FAIR tasks" 814 depends on CPU_FREQ_GOV_SCHEDUTIL 815 help 816 This feature enables the scheduler to track the clamped utilization 817 of each CPU based on RUNNABLE tasks scheduled on that CPU. 818 819 With this option, the user can specify the min and max CPU 820 utilization allowed for RUNNABLE tasks. The max utilization defines 821 the maximum frequency a task should use while the min utilization 822 defines the minimum frequency it should use. 823 824 Both min and max utilization clamp values are hints to the scheduler, 825 aiming at improving its frequency selection policy, but they do not 826 enforce or grant any specific bandwidth for tasks. 827 828 If in doubt, say N. 829 830config UCLAMP_BUCKETS_COUNT 831 int "Number of supported utilization clamp buckets" 832 range 5 20 833 default 5 834 depends on UCLAMP_TASK 835 help 836 Defines the number of clamp buckets to use. The range of each bucket 837 will be SCHED_CAPACITY_SCALE/UCLAMP_BUCKETS_COUNT. The higher the 838 number of clamp buckets the finer their granularity and the higher 839 the precision of clamping aggregation and tracking at run-time. 840 841 For example, with the minimum configuration value we will have 5 842 clamp buckets tracking 20% utilization each. A 25% boosted tasks will 843 be refcounted in the [20..39]% bucket and will set the bucket clamp 844 effective value to 25%. 845 If a second 30% boosted task should be co-scheduled on the same CPU, 846 that task will be refcounted in the same bucket of the first task and 847 it will boost the bucket clamp effective value to 30%. 848 The clamp effective value of a bucket is reset to its nominal value 849 (20% in the example above) when there are no more tasks refcounted in 850 that bucket. 851 852 An additional boost/capping margin can be added to some tasks. In the 853 example above the 25% task will be boosted to 30% until it exits the 854 CPU. If that should be considered not acceptable on certain systems, 855 it's always possible to reduce the margin by increasing the number of 856 clamp buckets to trade off used memory for run-time tracking 857 precision. 858 859 If in doubt, use the default value. 860 861source "kernel/sched/rtg/Kconfig" 862 863config SCHED_EAS 864 bool "EAS scheduler optimization" 865 default n 866 help 867 Check and migrate the CFS process to a more suitable CPU in the tick. 868 869config SCHED_RT_CAS 870 bool "rt-cas optimization" 871 depends on SCHED_EAS 872 default n 873 help 874 RT task detects capacity during CPU selection 875 876config SCHED_RT_ACTIVE_LB 877 bool "RT Capacity Aware Misfit Task" 878 depends on SCHED_EAS 879 default n 880 help 881 Check and migrate the RT process to a more suitable CPU in the tick. 882 883endmenu 884 885# 886# For architectures that want to enable the support for NUMA-affine scheduler 887# balancing logic: 888# 889config ARCH_SUPPORTS_NUMA_BALANCING 890 bool 891 892# 893# For architectures that prefer to flush all TLBs after a number of pages 894# are unmapped instead of sending one IPI per page to flush. The architecture 895# must provide guarantees on what happens if a clean TLB cache entry is 896# written after the unmap. Details are in mm/rmap.c near the check for 897# should_defer_flush. The architecture should also consider if the full flush 898# and the refill costs are offset by the savings of sending fewer IPIs. 899config ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH 900 bool 901 902config CC_HAS_INT128 903 def_bool !$(cc-option,$(m64-flag) -D__SIZEOF_INT128__=0) && 64BIT 904 905# 906# For architectures that know their GCC __int128 support is sound 907# 908config ARCH_SUPPORTS_INT128 909 bool 910 911# For architectures that (ab)use NUMA to represent different memory regions 912# all cpu-local but of different latencies, such as SuperH. 913# 914config ARCH_WANT_NUMA_VARIABLE_LOCALITY 915 bool 916 917config NUMA_BALANCING 918 bool "Memory placement aware NUMA scheduler" 919 depends on ARCH_SUPPORTS_NUMA_BALANCING 920 depends on !ARCH_WANT_NUMA_VARIABLE_LOCALITY 921 depends on SMP && NUMA && MIGRATION 922 help 923 This option adds support for automatic NUMA aware memory/task placement. 924 The mechanism is quite primitive and is based on migrating memory when 925 it has references to the node the task is running on. 926 927 This system will be inactive on UMA systems. 928 929config NUMA_BALANCING_DEFAULT_ENABLED 930 bool "Automatically enable NUMA aware memory/task placement" 931 default y 932 depends on NUMA_BALANCING 933 help 934 If set, automatic NUMA balancing will be enabled if running on a NUMA 935 machine. 936 937menuconfig CGROUPS 938 bool "Control Group support" 939 select KERNFS 940 help 941 This option adds support for grouping sets of processes together, for 942 use with process control subsystems such as Cpusets, CFS, memory 943 controls or device isolation. 944 See 945 - Documentation/scheduler/sched-design-CFS.rst (CFS) 946 - Documentation/admin-guide/cgroup-v1/ (features for grouping, isolation 947 and resource control) 948 949 Say N if unsure. 950 951if CGROUPS 952 953config PAGE_COUNTER 954 bool 955 956config MEMCG 957 bool "Memory controller" 958 select PAGE_COUNTER 959 select EVENTFD 960 help 961 Provides control over the memory footprint of tasks in a cgroup. 962 963config MEMCG_SWAP 964 bool 965 depends on MEMCG && SWAP 966 default y 967 968config MEMCG_KMEM 969 bool 970 depends on MEMCG && !SLOB 971 default y 972 973config BLK_CGROUP 974 bool "IO controller" 975 depends on BLOCK 976 default n 977 help 978 Generic block IO controller cgroup interface. This is the common 979 cgroup interface which should be used by various IO controlling 980 policies. 981 982 Currently, CFQ IO scheduler uses it to recognize task groups and 983 control disk bandwidth allocation (proportional time slice allocation) 984 to such task groups. It is also used by bio throttling logic in 985 block layer to implement upper limit in IO rates on a device. 986 987 This option only enables generic Block IO controller infrastructure. 988 One needs to also enable actual IO controlling logic/policy. For 989 enabling proportional weight division of disk bandwidth in CFQ, set 990 CONFIG_BFQ_GROUP_IOSCHED=y; for enabling throttling policy, set 991 CONFIG_BLK_DEV_THROTTLING=y. 992 993 See Documentation/admin-guide/cgroup-v1/blkio-controller.rst for more information. 994 995config CGROUP_WRITEBACK 996 bool 997 depends on MEMCG && BLK_CGROUP 998 default y 999 1000menuconfig CGROUP_SCHED 1001 bool "CPU controller" 1002 default n 1003 help 1004 This feature lets CPU scheduler recognize task groups and control CPU 1005 bandwidth allocation to such task groups. It uses cgroups to group 1006 tasks. 1007 1008if CGROUP_SCHED 1009config FAIR_GROUP_SCHED 1010 bool "Group scheduling for SCHED_OTHER" 1011 depends on CGROUP_SCHED 1012 default CGROUP_SCHED 1013 1014config CFS_BANDWIDTH 1015 bool "CPU bandwidth provisioning for FAIR_GROUP_SCHED" 1016 depends on FAIR_GROUP_SCHED 1017 default n 1018 help 1019 This option allows users to define CPU bandwidth rates (limits) for 1020 tasks running within the fair group scheduler. Groups with no limit 1021 set are considered to be unconstrained and will run with no 1022 restriction. 1023 See Documentation/scheduler/sched-bwc.rst for more information. 1024 1025config RT_GROUP_SCHED 1026 bool "Group scheduling for SCHED_RR/FIFO" 1027 depends on CGROUP_SCHED 1028 default n 1029 help 1030 This feature lets you explicitly allocate real CPU bandwidth 1031 to task groups. If enabled, it will also make it impossible to 1032 schedule realtime tasks for non-root users until you allocate 1033 realtime bandwidth for them. 1034 See Documentation/scheduler/sched-rt-group.rst for more information. 1035 1036endif #CGROUP_SCHED 1037 1038config UCLAMP_TASK_GROUP 1039 bool "Utilization clamping per group of tasks" 1040 depends on CGROUP_SCHED 1041 depends on UCLAMP_TASK 1042 default n 1043 help 1044 This feature enables the scheduler to track the clamped utilization 1045 of each CPU based on RUNNABLE tasks currently scheduled on that CPU. 1046 1047 When this option is enabled, the user can specify a min and max 1048 CPU bandwidth which is allowed for each single task in a group. 1049 The max bandwidth allows to clamp the maximum frequency a task 1050 can use, while the min bandwidth allows to define a minimum 1051 frequency a task will always use. 1052 1053 When task group based utilization clamping is enabled, an eventually 1054 specified task-specific clamp value is constrained by the cgroup 1055 specified clamp value. Both minimum and maximum task clamping cannot 1056 be bigger than the corresponding clamping defined at task group level. 1057 1058 If in doubt, say N. 1059 1060config CGROUP_PIDS 1061 bool "PIDs controller" 1062 help 1063 Provides enforcement of process number limits in the scope of a 1064 cgroup. Any attempt to fork more processes than is allowed in the 1065 cgroup will fail. PIDs are fundamentally a global resource because it 1066 is fairly trivial to reach PID exhaustion before you reach even a 1067 conservative kmemcg limit. As a result, it is possible to grind a 1068 system to halt without being limited by other cgroup policies. The 1069 PIDs controller is designed to stop this from happening. 1070 1071 It should be noted that organisational operations (such as attaching 1072 to a cgroup hierarchy) will *not* be blocked by the PIDs controller, 1073 since the PIDs limit only affects a process's ability to fork, not to 1074 attach to a cgroup. 1075 1076config CGROUP_RDMA 1077 bool "RDMA controller" 1078 help 1079 Provides enforcement of RDMA resources defined by IB stack. 1080 It is fairly easy for consumers to exhaust RDMA resources, which 1081 can result into resource unavailability to other consumers. 1082 RDMA controller is designed to stop this from happening. 1083 Attaching processes with active RDMA resources to the cgroup 1084 hierarchy is allowed even if can cross the hierarchy's limit. 1085 1086config CGROUP_FREEZER 1087 bool "Freezer controller" 1088 help 1089 Provides a way to freeze and unfreeze all tasks in a 1090 cgroup. 1091 1092 This option affects the ORIGINAL cgroup interface. The cgroup2 memory 1093 controller includes important in-kernel memory consumers per default. 1094 1095 If you're using cgroup2, say N. 1096 1097config CGROUP_HUGETLB 1098 bool "HugeTLB controller" 1099 depends on HUGETLB_PAGE 1100 select PAGE_COUNTER 1101 default n 1102 help 1103 Provides a cgroup controller for HugeTLB pages. 1104 When you enable this, you can put a per cgroup limit on HugeTLB usage. 1105 The limit is enforced during page fault. Since HugeTLB doesn't 1106 support page reclaim, enforcing the limit at page fault time implies 1107 that, the application will get SIGBUS signal if it tries to access 1108 HugeTLB pages beyond its limit. This requires the application to know 1109 beforehand how much HugeTLB pages it would require for its use. The 1110 control group is tracked in the third page lru pointer. This means 1111 that we cannot use the controller with huge page less than 3 pages. 1112 1113config CPUSETS 1114 bool "Cpuset controller" 1115 depends on SMP 1116 help 1117 This option will let you create and manage CPUSETs which 1118 allow dynamically partitioning a system into sets of CPUs and 1119 Memory Nodes and assigning tasks to run only within those sets. 1120 This is primarily useful on large SMP or NUMA systems. 1121 1122 Say N if unsure. 1123 1124config PROC_PID_CPUSET 1125 bool "Include legacy /proc/<pid>/cpuset file" 1126 depends on CPUSETS 1127 default y 1128 1129config CGROUP_DEVICE 1130 bool "Device controller" 1131 help 1132 Provides a cgroup controller implementing whitelists for 1133 devices which a process in the cgroup can mknod or open. 1134 1135config CGROUP_CPUACCT 1136 bool "Simple CPU accounting controller" 1137 help 1138 Provides a simple controller for monitoring the 1139 total CPU consumed by the tasks in a cgroup. 1140 1141config CGROUP_PERF 1142 bool "Perf controller" 1143 depends on PERF_EVENTS 1144 help 1145 This option extends the perf per-cpu mode to restrict monitoring 1146 to threads which belong to the cgroup specified and run on the 1147 designated cpu. Or this can be used to have cgroup ID in samples 1148 so that it can monitor performance events among cgroups. 1149 1150 Say N if unsure. 1151 1152config CGROUP_BPF 1153 bool "Support for eBPF programs attached to cgroups" 1154 depends on BPF_SYSCALL 1155 select SOCK_CGROUP_DATA 1156 help 1157 Allow attaching eBPF programs to a cgroup using the bpf(2) 1158 syscall command BPF_PROG_ATTACH. 1159 1160 In which context these programs are accessed depends on the type 1161 of attachment. For instance, programs that are attached using 1162 BPF_CGROUP_INET_INGRESS will be executed on the ingress path of 1163 inet sockets. 1164 1165config CGROUP_DEBUG 1166 bool "Debug controller" 1167 default n 1168 depends on DEBUG_KERNEL 1169 help 1170 This option enables a simple controller that exports 1171 debugging information about the cgroups framework. This 1172 controller is for control cgroup debugging only. Its 1173 interfaces are not stable. 1174 1175 Say N. 1176 1177config SOCK_CGROUP_DATA 1178 bool 1179 default n 1180 1181endif # CGROUPS 1182 1183menuconfig NAMESPACES 1184 bool "Namespaces support" if EXPERT 1185 depends on MULTIUSER 1186 default !EXPERT 1187 help 1188 Provides the way to make tasks work with different objects using 1189 the same id. For example same IPC id may refer to different objects 1190 or same user id or pid may refer to different tasks when used in 1191 different namespaces. 1192 1193if NAMESPACES 1194 1195config UTS_NS 1196 bool "UTS namespace" 1197 default y 1198 help 1199 In this namespace tasks see different info provided with the 1200 uname() system call 1201 1202config TIME_NS 1203 bool "TIME namespace" 1204 depends on GENERIC_VDSO_TIME_NS 1205 default y 1206 help 1207 In this namespace boottime and monotonic clocks can be set. 1208 The time will keep going with the same pace. 1209 1210config IPC_NS 1211 bool "IPC namespace" 1212 depends on (SYSVIPC || POSIX_MQUEUE) 1213 default y 1214 help 1215 In this namespace tasks work with IPC ids which correspond to 1216 different IPC objects in different namespaces. 1217 1218config USER_NS 1219 bool "User namespace" 1220 default n 1221 help 1222 This allows containers, i.e. vservers, to use user namespaces 1223 to provide different user info for different servers. 1224 1225 When user namespaces are enabled in the kernel it is 1226 recommended that the MEMCG option also be enabled and that 1227 user-space use the memory control groups to limit the amount 1228 of memory a memory unprivileged users can use. 1229 1230 If unsure, say N. 1231 1232config PID_NS 1233 bool "PID Namespaces" 1234 default y 1235 help 1236 Support process id namespaces. This allows having multiple 1237 processes with the same pid as long as they are in different 1238 pid namespaces. This is a building block of containers. 1239 1240config NET_NS 1241 bool "Network namespace" 1242 depends on NET 1243 default y 1244 help 1245 Allow user space to create what appear to be multiple instances 1246 of the network stack. 1247 1248endif # NAMESPACES 1249 1250config CHECKPOINT_RESTORE 1251 bool "Checkpoint/restore support" 1252 select PROC_CHILDREN 1253 select KCMP 1254 default n 1255 help 1256 Enables additional kernel features in a sake of checkpoint/restore. 1257 In particular it adds auxiliary prctl codes to setup process text, 1258 data and heap segment sizes, and a few additional /proc filesystem 1259 entries. 1260 1261 If unsure, say N here. 1262 1263config SCHED_AUTOGROUP 1264 bool "Automatic process group scheduling" 1265 select CGROUPS 1266 select CGROUP_SCHED 1267 select FAIR_GROUP_SCHED 1268 help 1269 This option optimizes the scheduler for common desktop workloads by 1270 automatically creating and populating task groups. This separation 1271 of workloads isolates aggressive CPU burners (like build jobs) from 1272 desktop applications. Task group autogeneration is currently based 1273 upon task session. 1274 1275config SYSFS_DEPRECATED 1276 bool "Enable deprecated sysfs features to support old userspace tools" 1277 depends on SYSFS 1278 default n 1279 help 1280 This option adds code that switches the layout of the "block" class 1281 devices, to not show up in /sys/class/block/, but only in 1282 /sys/block/. 1283 1284 This switch is only active when the sysfs.deprecated=1 boot option is 1285 passed or the SYSFS_DEPRECATED_V2 option is set. 1286 1287 This option allows new kernels to run on old distributions and tools, 1288 which might get confused by /sys/class/block/. Since 2007/2008 all 1289 major distributions and tools handle this just fine. 1290 1291 Recent distributions and userspace tools after 2009/2010 depend on 1292 the existence of /sys/class/block/, and will not work with this 1293 option enabled. 1294 1295 Only if you are using a new kernel on an old distribution, you might 1296 need to say Y here. 1297 1298config SYSFS_DEPRECATED_V2 1299 bool "Enable deprecated sysfs features by default" 1300 default n 1301 depends on SYSFS 1302 depends on SYSFS_DEPRECATED 1303 help 1304 Enable deprecated sysfs by default. 1305 1306 See the CONFIG_SYSFS_DEPRECATED option for more details about this 1307 option. 1308 1309 Only if you are using a new kernel on an old distribution, you might 1310 need to say Y here. Even then, odds are you would not need it 1311 enabled, you can always pass the boot option if absolutely necessary. 1312 1313config RELAY 1314 bool "Kernel->user space relay support (formerly relayfs)" 1315 select IRQ_WORK 1316 help 1317 This option enables support for relay interface support in 1318 certain file systems (such as debugfs). 1319 It is designed to provide an efficient mechanism for tools and 1320 facilities to relay large amounts of data from kernel space to 1321 user space. 1322 1323 If unsure, say N. 1324 1325config BLK_DEV_INITRD 1326 bool "Initial RAM filesystem and RAM disk (initramfs/initrd) support" 1327 help 1328 The initial RAM filesystem is a ramfs which is loaded by the 1329 boot loader (loadlin or lilo) and that is mounted as root 1330 before the normal boot procedure. It is typically used to 1331 load modules needed to mount the "real" root file system, 1332 etc. See <file:Documentation/admin-guide/initrd.rst> for details. 1333 1334 If RAM disk support (BLK_DEV_RAM) is also included, this 1335 also enables initial RAM disk (initrd) support and adds 1336 15 Kbytes (more on some other architectures) to the kernel size. 1337 1338 If unsure say Y. 1339 1340if BLK_DEV_INITRD 1341 1342source "usr/Kconfig" 1343 1344endif 1345 1346config BOOT_CONFIG 1347 bool "Boot config support" 1348 select BLK_DEV_INITRD 1349 help 1350 Extra boot config allows system admin to pass a config file as 1351 complemental extension of kernel cmdline when booting. 1352 The boot config file must be attached at the end of initramfs 1353 with checksum, size and magic word. 1354 See <file:Documentation/admin-guide/bootconfig.rst> for details. 1355 1356 If unsure, say Y. 1357 1358choice 1359 prompt "Compiler optimization level" 1360 default CC_OPTIMIZE_FOR_PERFORMANCE 1361 1362config CC_OPTIMIZE_FOR_PERFORMANCE 1363 bool "Optimize for performance (-O2)" 1364 help 1365 This is the default optimization level for the kernel, building 1366 with the "-O2" compiler flag for best performance and most 1367 helpful compile-time warnings. 1368 1369config CC_OPTIMIZE_FOR_PERFORMANCE_O3 1370 bool "Optimize more for performance (-O3)" 1371 depends on ARC 1372 help 1373 Choosing this option will pass "-O3" to your compiler to optimize 1374 the kernel yet more for performance. 1375 1376config CC_OPTIMIZE_FOR_SIZE 1377 bool "Optimize for size (-Os)" 1378 help 1379 Choosing this option will pass "-Os" to your compiler resulting 1380 in a smaller kernel. 1381 1382endchoice 1383 1384config HAVE_LD_DEAD_CODE_DATA_ELIMINATION 1385 bool 1386 help 1387 This requires that the arch annotates or otherwise protects 1388 its external entry points from being discarded. Linker scripts 1389 must also merge .text.*, .data.*, and .bss.* correctly into 1390 output sections. Care must be taken not to pull in unrelated 1391 sections (e.g., '.text.init'). Typically '.' in section names 1392 is used to distinguish them from label names / C identifiers. 1393 1394config LD_DEAD_CODE_DATA_ELIMINATION 1395 bool "Dead code and data elimination (EXPERIMENTAL)" 1396 depends on HAVE_LD_DEAD_CODE_DATA_ELIMINATION 1397 depends on EXPERT 1398 depends on $(cc-option,-ffunction-sections -fdata-sections) 1399 depends on $(ld-option,--gc-sections) 1400 help 1401 Enable this if you want to do dead code and data elimination with 1402 the linker by compiling with -ffunction-sections -fdata-sections, 1403 and linking with --gc-sections. 1404 1405 This can reduce on disk and in-memory size of the kernel 1406 code and static data, particularly for small configs and 1407 on small systems. This has the possibility of introducing 1408 silently broken kernel if the required annotations are not 1409 present. This option is not well tested yet, so use at your 1410 own risk. 1411 1412config LD_ORPHAN_WARN 1413 def_bool y 1414 depends on ARCH_WANT_LD_ORPHAN_WARN 1415 depends on !LD_IS_LLD || LLD_VERSION >= 110000 1416 depends on $(ld-option,--orphan-handling=warn) 1417 1418config SYSCTL 1419 bool 1420 1421config HAVE_UID16 1422 bool 1423 1424config SYSCTL_EXCEPTION_TRACE 1425 bool 1426 help 1427 Enable support for /proc/sys/debug/exception-trace. 1428 1429config SYSCTL_ARCH_UNALIGN_NO_WARN 1430 bool 1431 help 1432 Enable support for /proc/sys/kernel/ignore-unaligned-usertrap 1433 Allows arch to define/use @no_unaligned_warning to possibly warn 1434 about unaligned access emulation going on under the hood. 1435 1436config SYSCTL_ARCH_UNALIGN_ALLOW 1437 bool 1438 help 1439 Enable support for /proc/sys/kernel/unaligned-trap 1440 Allows arches to define/use @unaligned_enabled to runtime toggle 1441 the unaligned access emulation. 1442 see arch/parisc/kernel/unaligned.c for reference 1443 1444config HAVE_PCSPKR_PLATFORM 1445 bool 1446 1447# interpreter that classic socket filters depend on 1448config BPF 1449 bool 1450 1451menuconfig EXPERT 1452 bool "Configure standard kernel features (expert users)" 1453 # Unhide debug options, to make the on-by-default options visible 1454 select DEBUG_KERNEL 1455 help 1456 This option allows certain base kernel options and settings 1457 to be disabled or tweaked. This is for specialized 1458 environments which can tolerate a "non-standard" kernel. 1459 Only use this if you really know what you are doing. 1460 1461config UID16 1462 bool "Enable 16-bit UID system calls" if EXPERT 1463 depends on HAVE_UID16 && MULTIUSER 1464 default y 1465 help 1466 This enables the legacy 16-bit UID syscall wrappers. 1467 1468config MULTIUSER 1469 bool "Multiple users, groups and capabilities support" if EXPERT 1470 default y 1471 help 1472 This option enables support for non-root users, groups and 1473 capabilities. 1474 1475 If you say N here, all processes will run with UID 0, GID 0, and all 1476 possible capabilities. Saying N here also compiles out support for 1477 system calls related to UIDs, GIDs, and capabilities, such as setuid, 1478 setgid, and capset. 1479 1480 If unsure, say Y here. 1481 1482config SGETMASK_SYSCALL 1483 bool "sgetmask/ssetmask syscalls support" if EXPERT 1484 def_bool PARISC || M68K || PPC || MIPS || X86 || SPARC || MICROBLAZE || SUPERH 1485 help 1486 sys_sgetmask and sys_ssetmask are obsolete system calls 1487 no longer supported in libc but still enabled by default in some 1488 architectures. 1489 1490 If unsure, leave the default option here. 1491 1492config SYSFS_SYSCALL 1493 bool "Sysfs syscall support" if EXPERT 1494 default y 1495 help 1496 sys_sysfs is an obsolete system call no longer supported in libc. 1497 Note that disabling this option is more secure but might break 1498 compatibility with some systems. 1499 1500 If unsure say Y here. 1501 1502config FHANDLE 1503 bool "open by fhandle syscalls" if EXPERT 1504 select EXPORTFS 1505 default y 1506 help 1507 If you say Y here, a user level program will be able to map 1508 file names to handle and then later use the handle for 1509 different file system operations. This is useful in implementing 1510 userspace file servers, which now track files using handles instead 1511 of names. The handle would remain the same even if file names 1512 get renamed. Enables open_by_handle_at(2) and name_to_handle_at(2) 1513 syscalls. 1514 1515config POSIX_TIMERS 1516 bool "Posix Clocks & timers" if EXPERT 1517 default y 1518 help 1519 This includes native support for POSIX timers to the kernel. 1520 Some embedded systems have no use for them and therefore they 1521 can be configured out to reduce the size of the kernel image. 1522 1523 When this option is disabled, the following syscalls won't be 1524 available: timer_create, timer_gettime: timer_getoverrun, 1525 timer_settime, timer_delete, clock_adjtime, getitimer, 1526 setitimer, alarm. Furthermore, the clock_settime, clock_gettime, 1527 clock_getres and clock_nanosleep syscalls will be limited to 1528 CLOCK_REALTIME, CLOCK_MONOTONIC and CLOCK_BOOTTIME only. 1529 1530 If unsure say y. 1531 1532config PRINTK 1533 default y 1534 bool "Enable support for printk" if EXPERT 1535 select IRQ_WORK 1536 help 1537 This option enables normal printk support. Removing it 1538 eliminates most of the message strings from the kernel image 1539 and makes the kernel more or less silent. As this makes it 1540 very difficult to diagnose system problems, saying N here is 1541 strongly discouraged. 1542 1543config PRINTK_NMI 1544 def_bool y 1545 depends on PRINTK 1546 depends on HAVE_NMI 1547 1548config BUG 1549 bool "BUG() support" if EXPERT 1550 default y 1551 help 1552 Disabling this option eliminates support for BUG and WARN, reducing 1553 the size of your kernel image and potentially quietly ignoring 1554 numerous fatal conditions. You should only consider disabling this 1555 option for embedded systems with no facilities for reporting errors. 1556 Just say Y. 1557 1558config ELF_CORE 1559 depends on COREDUMP 1560 default y 1561 bool "Enable ELF core dumps" if EXPERT 1562 help 1563 Enable support for generating core dumps. Disabling saves about 4k. 1564 1565 1566config PCSPKR_PLATFORM 1567 bool "Enable PC-Speaker support" if EXPERT 1568 depends on HAVE_PCSPKR_PLATFORM 1569 select I8253_LOCK 1570 default y 1571 help 1572 This option allows to disable the internal PC-Speaker 1573 support, saving some memory. 1574 1575config BASE_FULL 1576 default y 1577 bool "Enable full-sized data structures for core" if EXPERT 1578 help 1579 Disabling this option reduces the size of miscellaneous core 1580 kernel data structures. This saves memory on small machines, 1581 but may reduce performance. 1582 1583config FUTEX 1584 bool "Enable futex support" if EXPERT 1585 default y 1586 imply RT_MUTEXES 1587 help 1588 Disabling this option will cause the kernel to be built without 1589 support for "fast userspace mutexes". The resulting kernel may not 1590 run glibc-based applications correctly. 1591 1592config FUTEX_PI 1593 bool 1594 depends on FUTEX && RT_MUTEXES 1595 default y 1596 1597config HAVE_FUTEX_CMPXCHG 1598 bool 1599 depends on FUTEX 1600 help 1601 Architectures should select this if futex_atomic_cmpxchg_inatomic() 1602 is implemented and always working. This removes a couple of runtime 1603 checks. 1604 1605config EPOLL 1606 bool "Enable eventpoll support" if EXPERT 1607 default y 1608 help 1609 Disabling this option will cause the kernel to be built without 1610 support for epoll family of system calls. 1611 1612config SIGNALFD 1613 bool "Enable signalfd() system call" if EXPERT 1614 default y 1615 help 1616 Enable the signalfd() system call that allows to receive signals 1617 on a file descriptor. 1618 1619 If unsure, say Y. 1620 1621config TIMERFD 1622 bool "Enable timerfd() system call" if EXPERT 1623 default y 1624 help 1625 Enable the timerfd() system call that allows to receive timer 1626 events on a file descriptor. 1627 1628 If unsure, say Y. 1629 1630config EVENTFD 1631 bool "Enable eventfd() system call" if EXPERT 1632 default y 1633 help 1634 Enable the eventfd() system call that allows to receive both 1635 kernel notification (ie. KAIO) or userspace notifications. 1636 1637 If unsure, say Y. 1638 1639config SHMEM 1640 bool "Use full shmem filesystem" if EXPERT 1641 default y 1642 depends on MMU 1643 help 1644 The shmem is an internal filesystem used to manage shared memory. 1645 It is backed by swap and manages resource limits. It is also exported 1646 to userspace as tmpfs if TMPFS is enabled. Disabling this 1647 option replaces shmem and tmpfs with the much simpler ramfs code, 1648 which may be appropriate on small systems without swap. 1649 1650config AIO 1651 bool "Enable AIO support" if EXPERT 1652 default y 1653 help 1654 This option enables POSIX asynchronous I/O which may by used 1655 by some high performance threaded applications. Disabling 1656 this option saves about 7k. 1657 1658config IO_URING 1659 bool "Enable IO uring support" if EXPERT 1660 select IO_WQ 1661 default y 1662 help 1663 This option enables support for the io_uring interface, enabling 1664 applications to submit and complete IO through submission and 1665 completion rings that are shared between the kernel and application. 1666 1667config ADVISE_SYSCALLS 1668 bool "Enable madvise/fadvise syscalls" if EXPERT 1669 default y 1670 help 1671 This option enables the madvise and fadvise syscalls, used by 1672 applications to advise the kernel about their future memory or file 1673 usage, improving performance. If building an embedded system where no 1674 applications use these syscalls, you can disable this option to save 1675 space. 1676 1677config HAVE_ARCH_USERFAULTFD_WP 1678 bool 1679 help 1680 Arch has userfaultfd write protection support 1681 1682config MEMBARRIER 1683 bool "Enable membarrier() system call" if EXPERT 1684 default y 1685 help 1686 Enable the membarrier() system call that allows issuing memory 1687 barriers across all running threads, which can be used to distribute 1688 the cost of user-space memory barriers asymmetrically by transforming 1689 pairs of memory barriers into pairs consisting of membarrier() and a 1690 compiler barrier. 1691 1692 If unsure, say Y. 1693 1694config KALLSYMS 1695 bool "Load all symbols for debugging/ksymoops" if EXPERT 1696 default y 1697 help 1698 Say Y here to let the kernel print out symbolic crash information and 1699 symbolic stack backtraces. This increases the size of the kernel 1700 somewhat, as all symbols have to be loaded into the kernel image. 1701 1702config KALLSYMS_ALL 1703 bool "Include all symbols in kallsyms" 1704 depends on DEBUG_KERNEL && KALLSYMS 1705 help 1706 Normally kallsyms only contains the symbols of functions for nicer 1707 OOPS messages and backtraces (i.e., symbols from the text and inittext 1708 sections). This is sufficient for most cases. And only in very rare 1709 cases (e.g., when a debugger is used) all symbols are required (e.g., 1710 names of variables from the data sections, etc). 1711 1712 This option makes sure that all symbols are loaded into the kernel 1713 image (i.e., symbols from all sections) in cost of increased kernel 1714 size (depending on the kernel configuration, it may be 300KiB or 1715 something like this). 1716 1717 Say N unless you really need all symbols. 1718 1719config KALLSYMS_ABSOLUTE_PERCPU 1720 bool 1721 depends on KALLSYMS 1722 default X86_64 && SMP 1723 1724config KALLSYMS_BASE_RELATIVE 1725 bool 1726 depends on KALLSYMS 1727 default !IA64 1728 help 1729 Instead of emitting them as absolute values in the native word size, 1730 emit the symbol references in the kallsyms table as 32-bit entries, 1731 each containing a relative value in the range [base, base + U32_MAX] 1732 or, when KALLSYMS_ABSOLUTE_PERCPU is in effect, each containing either 1733 an absolute value in the range [0, S32_MAX] or a relative value in the 1734 range [base, base + S32_MAX], where base is the lowest relative symbol 1735 address encountered in the image. 1736 1737 On 64-bit builds, this reduces the size of the address table by 50%, 1738 but more importantly, it results in entries whose values are build 1739 time constants, and no relocation pass is required at runtime to fix 1740 up the entries based on the runtime load address of the kernel. 1741 1742# end of the "standard kernel features (expert users)" menu 1743 1744# syscall, maps, verifier 1745 1746config BPF_LSM 1747 bool "LSM Instrumentation with BPF" 1748 depends on BPF_EVENTS 1749 depends on BPF_SYSCALL 1750 depends on SECURITY 1751 depends on BPF_JIT 1752 help 1753 Enables instrumentation of the security hooks with eBPF programs for 1754 implementing dynamic MAC and Audit Policies. 1755 1756 If you are unsure how to answer this question, answer N. 1757 1758config BPF_SYSCALL 1759 bool "Enable bpf() system call" 1760 select BPF 1761 select IRQ_WORK 1762 select TASKS_TRACE_RCU 1763 default n 1764 help 1765 Enable the bpf() system call that allows to manipulate eBPF 1766 programs and maps via file descriptors. 1767 1768config ARCH_WANT_DEFAULT_BPF_JIT 1769 bool 1770 1771config BPF_JIT_ALWAYS_ON 1772 bool "Permanently enable BPF JIT and remove BPF interpreter" 1773 depends on BPF_SYSCALL && HAVE_EBPF_JIT && BPF_JIT 1774 help 1775 Enables BPF JIT and removes BPF interpreter to avoid 1776 speculative execution of BPF instructions by the interpreter 1777 1778config BPF_JIT_DEFAULT_ON 1779 def_bool ARCH_WANT_DEFAULT_BPF_JIT || BPF_JIT_ALWAYS_ON 1780 depends on HAVE_EBPF_JIT && BPF_JIT 1781 1782config BPF_UNPRIV_DEFAULT_OFF 1783 bool "Disable unprivileged BPF by default" 1784 depends on BPF_SYSCALL 1785 help 1786 Disables unprivileged BPF by default by setting the corresponding 1787 /proc/sys/kernel/unprivileged_bpf_disabled knob to 2. An admin can 1788 still reenable it by setting it to 0 later on, or permanently 1789 disable it by setting it to 1 (from which no other transition to 1790 0 is possible anymore). 1791 1792source "kernel/bpf/preload/Kconfig" 1793 1794config USERFAULTFD 1795 bool "Enable userfaultfd() system call" 1796 depends on MMU 1797 help 1798 Enable the userfaultfd() system call that allows to intercept and 1799 handle page faults in userland. 1800 1801config ARCH_HAS_MEMBARRIER_CALLBACKS 1802 bool 1803 1804config ARCH_HAS_MEMBARRIER_SYNC_CORE 1805 bool 1806 1807config KCMP 1808 bool "Enable kcmp() system call" if EXPERT 1809 help 1810 Enable the kernel resource comparison system call. It provides 1811 user-space with the ability to compare two processes to see if they 1812 share a common resource, such as a file descriptor or even virtual 1813 memory space. 1814 1815 If unsure, say N. 1816 1817config RSEQ 1818 bool "Enable rseq() system call" if EXPERT 1819 default y 1820 depends on HAVE_RSEQ 1821 select MEMBARRIER 1822 help 1823 Enable the restartable sequences system call. It provides a 1824 user-space cache for the current CPU number value, which 1825 speeds up getting the current CPU number from user-space, 1826 as well as an ABI to speed up user-space operations on 1827 per-CPU data. 1828 1829 If unsure, say Y. 1830 1831config DEBUG_RSEQ 1832 default n 1833 bool "Enabled debugging of rseq() system call" if EXPERT 1834 depends on RSEQ && DEBUG_KERNEL 1835 help 1836 Enable extra debugging checks for the rseq system call. 1837 1838 If unsure, say N. 1839 1840config EMBEDDED 1841 bool "Embedded system" 1842 option allnoconfig_y 1843 select EXPERT 1844 help 1845 This option should be enabled if compiling the kernel for 1846 an embedded system so certain expert options are available 1847 for configuration. 1848 1849config HAVE_PERF_EVENTS 1850 bool 1851 help 1852 See tools/perf/design.txt for details. 1853 1854config PERF_USE_VMALLOC 1855 bool 1856 help 1857 See tools/perf/design.txt for details 1858 1859config PC104 1860 bool "PC/104 support" if EXPERT 1861 help 1862 Expose PC/104 form factor device drivers and options available for 1863 selection and configuration. Enable this option if your target 1864 machine has a PC/104 bus. 1865 1866menu "Kernel Performance Events And Counters" 1867 1868config PERF_EVENTS 1869 bool "Kernel performance events and counters" 1870 default y if PROFILING 1871 depends on HAVE_PERF_EVENTS 1872 select IRQ_WORK 1873 select SRCU 1874 help 1875 Enable kernel support for various performance events provided 1876 by software and hardware. 1877 1878 Software events are supported either built-in or via the 1879 use of generic tracepoints. 1880 1881 Most modern CPUs support performance events via performance 1882 counter registers. These registers count the number of certain 1883 types of hw events: such as instructions executed, cachemisses 1884 suffered, or branches mis-predicted - without slowing down the 1885 kernel or applications. These registers can also trigger interrupts 1886 when a threshold number of events have passed - and can thus be 1887 used to profile the code that runs on that CPU. 1888 1889 The Linux Performance Event subsystem provides an abstraction of 1890 these software and hardware event capabilities, available via a 1891 system call and used by the "perf" utility in tools/perf/. It 1892 provides per task and per CPU counters, and it provides event 1893 capabilities on top of those. 1894 1895 Say Y if unsure. 1896 1897config DEBUG_PERF_USE_VMALLOC 1898 default n 1899 bool "Debug: use vmalloc to back perf mmap() buffers" 1900 depends on PERF_EVENTS && DEBUG_KERNEL && !PPC 1901 select PERF_USE_VMALLOC 1902 help 1903 Use vmalloc memory to back perf mmap() buffers. 1904 1905 Mostly useful for debugging the vmalloc code on platforms 1906 that don't require it. 1907 1908 Say N if unsure. 1909 1910endmenu 1911 1912config VM_EVENT_COUNTERS 1913 default y 1914 bool "Enable VM event counters for /proc/vmstat" if EXPERT 1915 help 1916 VM event counters are needed for event counts to be shown. 1917 This option allows the disabling of the VM event counters 1918 on EXPERT systems. /proc/vmstat will only show page counts 1919 if VM event counters are disabled. 1920 1921config SLUB_DEBUG 1922 default y 1923 bool "Enable SLUB debugging support" if EXPERT 1924 depends on SLUB && SYSFS 1925 help 1926 SLUB has extensive debug support features. Disabling these can 1927 result in significant savings in code size. This also disables 1928 SLUB sysfs support. /sys/slab will not exist and there will be 1929 no support for cache validation etc. 1930 1931config SLUB_MEMCG_SYSFS_ON 1932 default n 1933 bool "Enable memcg SLUB sysfs support by default" if EXPERT 1934 depends on SLUB && SYSFS && MEMCG 1935 help 1936 SLUB creates a directory under /sys/kernel/slab for each 1937 allocation cache to host info and debug files. If memory 1938 cgroup is enabled, each cache can have per memory cgroup 1939 caches. SLUB can create the same sysfs directories for these 1940 caches under /sys/kernel/slab/CACHE/cgroup but it can lead 1941 to a very high number of debug files being created. This is 1942 controlled by slub_memcg_sysfs boot parameter and this 1943 config option determines the parameter's default value. 1944 1945config COMPAT_BRK 1946 bool "Disable heap randomization" 1947 default y 1948 help 1949 Randomizing heap placement makes heap exploits harder, but it 1950 also breaks ancient binaries (including anything libc5 based). 1951 This option changes the bootup default to heap randomization 1952 disabled, and can be overridden at runtime by setting 1953 /proc/sys/kernel/randomize_va_space to 2. 1954 1955 On non-ancient distros (post-2000 ones) N is usually a safe choice. 1956 1957choice 1958 prompt "Choose SLAB allocator" 1959 default SLUB 1960 help 1961 This option allows to select a slab allocator. 1962 1963config SLAB 1964 bool "SLAB" 1965 select HAVE_HARDENED_USERCOPY_ALLOCATOR 1966 help 1967 The regular slab allocator that is established and known to work 1968 well in all environments. It organizes cache hot objects in 1969 per cpu and per node queues. 1970 1971config SLUB 1972 bool "SLUB (Unqueued Allocator)" 1973 select HAVE_HARDENED_USERCOPY_ALLOCATOR 1974 help 1975 SLUB is a slab allocator that minimizes cache line usage 1976 instead of managing queues of cached objects (SLAB approach). 1977 Per cpu caching is realized using slabs of objects instead 1978 of queues of objects. SLUB can use memory efficiently 1979 and has enhanced diagnostics. SLUB is the default choice for 1980 a slab allocator. 1981 1982config SLOB 1983 depends on EXPERT 1984 bool "SLOB (Simple Allocator)" 1985 help 1986 SLOB replaces the stock allocator with a drastically simpler 1987 allocator. SLOB is generally more space efficient but 1988 does not perform as well on large systems. 1989 1990endchoice 1991 1992config SLAB_MERGE_DEFAULT 1993 bool "Allow slab caches to be merged" 1994 default y 1995 help 1996 For reduced kernel memory fragmentation, slab caches can be 1997 merged when they share the same size and other characteristics. 1998 This carries a risk of kernel heap overflows being able to 1999 overwrite objects from merged caches (and more easily control 2000 cache layout), which makes such heap attacks easier to exploit 2001 by attackers. By keeping caches unmerged, these kinds of exploits 2002 can usually only damage objects in the same cache. To disable 2003 merging at runtime, "slab_nomerge" can be passed on the kernel 2004 command line. 2005 2006config SLAB_FREELIST_RANDOM 2007 bool "Randomize slab freelist" 2008 depends on SLAB || SLUB 2009 help 2010 Randomizes the freelist order used on creating new pages. This 2011 security feature reduces the predictability of the kernel slab 2012 allocator against heap overflows. 2013 2014config SLAB_FREELIST_HARDENED 2015 bool "Harden slab freelist metadata" 2016 depends on SLAB || SLUB 2017 help 2018 Many kernel heap attacks try to target slab cache metadata and 2019 other infrastructure. This options makes minor performance 2020 sacrifices to harden the kernel slab allocator against common 2021 freelist exploit methods. Some slab implementations have more 2022 sanity-checking than others. This option is most effective with 2023 CONFIG_SLUB. 2024 2025config SHUFFLE_PAGE_ALLOCATOR 2026 bool "Page allocator randomization" 2027 default SLAB_FREELIST_RANDOM && ACPI_NUMA 2028 help 2029 Randomization of the page allocator improves the average 2030 utilization of a direct-mapped memory-side-cache. See section 2031 5.2.27 Heterogeneous Memory Attribute Table (HMAT) in the ACPI 2032 6.2a specification for an example of how a platform advertises 2033 the presence of a memory-side-cache. There are also incidental 2034 security benefits as it reduces the predictability of page 2035 allocations to compliment SLAB_FREELIST_RANDOM, but the 2036 default granularity of shuffling on the "MAX_ORDER - 1" i.e, 2037 10th order of pages is selected based on cache utilization 2038 benefits on x86. 2039 2040 While the randomization improves cache utilization it may 2041 negatively impact workloads on platforms without a cache. For 2042 this reason, by default, the randomization is enabled only 2043 after runtime detection of a direct-mapped memory-side-cache. 2044 Otherwise, the randomization may be force enabled with the 2045 'page_alloc.shuffle' kernel command line parameter. 2046 2047 Say Y if unsure. 2048 2049config SLUB_CPU_PARTIAL 2050 default y 2051 depends on SLUB && SMP 2052 bool "SLUB per cpu partial cache" 2053 help 2054 Per cpu partial caches accelerate objects allocation and freeing 2055 that is local to a processor at the price of more indeterminism 2056 in the latency of the free. On overflow these caches will be cleared 2057 which requires the taking of locks that may cause latency spikes. 2058 Typically one would choose no for a realtime system. 2059 2060config MMAP_ALLOW_UNINITIALIZED 2061 bool "Allow mmapped anonymous memory to be uninitialized" 2062 depends on EXPERT && !MMU 2063 default n 2064 help 2065 Normally, and according to the Linux spec, anonymous memory obtained 2066 from mmap() has its contents cleared before it is passed to 2067 userspace. Enabling this config option allows you to request that 2068 mmap() skip that if it is given an MAP_UNINITIALIZED flag, thus 2069 providing a huge performance boost. If this option is not enabled, 2070 then the flag will be ignored. 2071 2072 This is taken advantage of by uClibc's malloc(), and also by 2073 ELF-FDPIC binfmt's brk and stack allocator. 2074 2075 Because of the obvious security issues, this option should only be 2076 enabled on embedded devices where you control what is run in 2077 userspace. Since that isn't generally a problem on no-MMU systems, 2078 it is normally safe to say Y here. 2079 2080 See Documentation/admin-guide/mm/nommu-mmap.rst for more information. 2081 2082config SYSTEM_DATA_VERIFICATION 2083 def_bool n 2084 select SYSTEM_TRUSTED_KEYRING 2085 select KEYS 2086 select CRYPTO 2087 select CRYPTO_RSA 2088 select ASYMMETRIC_KEY_TYPE 2089 select ASYMMETRIC_PUBLIC_KEY_SUBTYPE 2090 select ASN1 2091 select OID_REGISTRY 2092 select X509_CERTIFICATE_PARSER 2093 select PKCS7_MESSAGE_PARSER 2094 help 2095 Provide PKCS#7 message verification using the contents of the system 2096 trusted keyring to provide public keys. This then can be used for 2097 module verification, kexec image verification and firmware blob 2098 verification. 2099 2100config PROFILING 2101 bool "Profiling support" 2102 help 2103 Say Y here to enable the extended profiling support mechanisms used 2104 by profilers such as OProfile. 2105 2106# 2107# Place an empty function call at each tracepoint site. Can be 2108# dynamically changed for a probe function. 2109# 2110config TRACEPOINTS 2111 bool 2112 2113endmenu # General setup 2114 2115source "arch/Kconfig" 2116 2117config RT_MUTEXES 2118 bool 2119 2120config BASE_SMALL 2121 int 2122 default 0 if BASE_FULL 2123 default 1 if !BASE_FULL 2124 2125config MODULE_SIG_FORMAT 2126 def_bool n 2127 select SYSTEM_DATA_VERIFICATION 2128 2129menuconfig MODULES 2130 bool "Enable loadable module support" 2131 option modules 2132 help 2133 Kernel modules are small pieces of compiled code which can 2134 be inserted in the running kernel, rather than being 2135 permanently built into the kernel. You use the "modprobe" 2136 tool to add (and sometimes remove) them. If you say Y here, 2137 many parts of the kernel can be built as modules (by 2138 answering M instead of Y where indicated): this is most 2139 useful for infrequently used options which are not required 2140 for booting. For more information, see the man pages for 2141 modprobe, lsmod, modinfo, insmod and rmmod. 2142 2143 If you say Y here, you will need to run "make 2144 modules_install" to put the modules under /lib/modules/ 2145 where modprobe can find them (you may need to be root to do 2146 this). 2147 2148 If unsure, say Y. 2149 2150if MODULES 2151 2152config MODULE_FORCE_LOAD 2153 bool "Forced module loading" 2154 default n 2155 help 2156 Allow loading of modules without version information (ie. modprobe 2157 --force). Forced module loading sets the 'F' (forced) taint flag and 2158 is usually a really bad idea. 2159 2160config MODULE_UNLOAD 2161 bool "Module unloading" 2162 help 2163 Without this option you will not be able to unload any 2164 modules (note that some modules may not be unloadable 2165 anyway), which makes your kernel smaller, faster 2166 and simpler. If unsure, say Y. 2167 2168config MODULE_FORCE_UNLOAD 2169 bool "Forced module unloading" 2170 depends on MODULE_UNLOAD 2171 help 2172 This option allows you to force a module to unload, even if the 2173 kernel believes it is unsafe: the kernel will remove the module 2174 without waiting for anyone to stop using it (using the -f option to 2175 rmmod). This is mainly for kernel developers and desperate users. 2176 If unsure, say N. 2177 2178config MODVERSIONS 2179 bool "Module versioning support" 2180 help 2181 Usually, you have to use modules compiled with your kernel. 2182 Saying Y here makes it sometimes possible to use modules 2183 compiled for different kernels, by adding enough information 2184 to the modules to (hopefully) spot any changes which would 2185 make them incompatible with the kernel you are running. If 2186 unsure, say N. 2187 2188config ASM_MODVERSIONS 2189 bool 2190 default HAVE_ASM_MODVERSIONS && MODVERSIONS 2191 help 2192 This enables module versioning for exported symbols also from 2193 assembly. This can be enabled only when the target architecture 2194 supports it. 2195 2196config MODULE_REL_CRCS 2197 bool 2198 depends on MODVERSIONS 2199 2200config MODULE_SRCVERSION_ALL 2201 bool "Source checksum for all modules" 2202 help 2203 Modules which contain a MODULE_VERSION get an extra "srcversion" 2204 field inserted into their modinfo section, which contains a 2205 sum of the source files which made it. This helps maintainers 2206 see exactly which source was used to build a module (since 2207 others sometimes change the module source without updating 2208 the version). With this option, such a "srcversion" field 2209 will be created for all modules. If unsure, say N. 2210 2211config MODULE_SIG 2212 bool "Module signature verification" 2213 select MODULE_SIG_FORMAT 2214 help 2215 Check modules for valid signatures upon load: the signature 2216 is simply appended to the module. For more information see 2217 <file:Documentation/admin-guide/module-signing.rst>. 2218 2219 Note that this option adds the OpenSSL development packages as a 2220 kernel build dependency so that the signing tool can use its crypto 2221 library. 2222 2223 You should enable this option if you wish to use either 2224 CONFIG_SECURITY_LOCKDOWN_LSM or lockdown functionality imposed via 2225 another LSM - otherwise unsigned modules will be loadable regardless 2226 of the lockdown policy. 2227 2228 !!!WARNING!!! If you enable this option, you MUST make sure that the 2229 module DOES NOT get stripped after being signed. This includes the 2230 debuginfo strip done by some packagers (such as rpmbuild) and 2231 inclusion into an initramfs that wants the module size reduced. 2232 2233config MODULE_SIG_FORCE 2234 bool "Require modules to be validly signed" 2235 depends on MODULE_SIG 2236 help 2237 Reject unsigned modules or signed modules for which we don't have a 2238 key. Without this, such modules will simply taint the kernel. 2239 2240config MODULE_SIG_ALL 2241 bool "Automatically sign all modules" 2242 default y 2243 depends on MODULE_SIG 2244 help 2245 Sign all modules during make modules_install. Without this option, 2246 modules must be signed manually, using the scripts/sign-file tool. 2247 2248comment "Do not forget to sign required modules with scripts/sign-file" 2249 depends on MODULE_SIG_FORCE && !MODULE_SIG_ALL 2250 2251choice 2252 prompt "Which hash algorithm should modules be signed with?" 2253 depends on MODULE_SIG 2254 help 2255 This determines which sort of hashing algorithm will be used during 2256 signature generation. This algorithm _must_ be built into the kernel 2257 directly so that signature verification can take place. It is not 2258 possible to load a signed module containing the algorithm to check 2259 the signature on that module. 2260 2261config MODULE_SIG_SHA1 2262 bool "Sign modules with SHA-1" 2263 select CRYPTO_SHA1 2264 2265config MODULE_SIG_SHA224 2266 bool "Sign modules with SHA-224" 2267 select CRYPTO_SHA256 2268 2269config MODULE_SIG_SHA256 2270 bool "Sign modules with SHA-256" 2271 select CRYPTO_SHA256 2272 2273config MODULE_SIG_SHA384 2274 bool "Sign modules with SHA-384" 2275 select CRYPTO_SHA512 2276 2277config MODULE_SIG_SHA512 2278 bool "Sign modules with SHA-512" 2279 select CRYPTO_SHA512 2280 2281endchoice 2282 2283config MODULE_SIG_HASH 2284 string 2285 depends on MODULE_SIG 2286 default "sha1" if MODULE_SIG_SHA1 2287 default "sha224" if MODULE_SIG_SHA224 2288 default "sha256" if MODULE_SIG_SHA256 2289 default "sha384" if MODULE_SIG_SHA384 2290 default "sha512" if MODULE_SIG_SHA512 2291 2292config MODULE_COMPRESS 2293 bool "Compress modules on installation" 2294 help 2295 2296 Compresses kernel modules when 'make modules_install' is run; gzip or 2297 xz depending on "Compression algorithm" below. 2298 2299 module-init-tools MAY support gzip, and kmod MAY support gzip and xz. 2300 2301 Out-of-tree kernel modules installed using Kbuild will also be 2302 compressed upon installation. 2303 2304 Note: for modules inside an initrd or initramfs, it's more efficient 2305 to compress the whole initrd or initramfs instead. 2306 2307 Note: This is fully compatible with signed modules. 2308 2309 If in doubt, say N. 2310 2311choice 2312 prompt "Compression algorithm" 2313 depends on MODULE_COMPRESS 2314 default MODULE_COMPRESS_GZIP 2315 help 2316 This determines which sort of compression will be used during 2317 'make modules_install'. 2318 2319 GZIP (default) and XZ are supported. 2320 2321config MODULE_COMPRESS_GZIP 2322 bool "GZIP" 2323 2324config MODULE_COMPRESS_XZ 2325 bool "XZ" 2326 2327endchoice 2328 2329config MODULE_ALLOW_MISSING_NAMESPACE_IMPORTS 2330 bool "Allow loading of modules with missing namespace imports" 2331 help 2332 Symbols exported with EXPORT_SYMBOL_NS*() are considered exported in 2333 a namespace. A module that makes use of a symbol exported with such a 2334 namespace is required to import the namespace via MODULE_IMPORT_NS(). 2335 There is no technical reason to enforce correct namespace imports, 2336 but it creates consistency between symbols defining namespaces and 2337 users importing namespaces they make use of. This option relaxes this 2338 requirement and lifts the enforcement when loading a module. 2339 2340 If unsure, say N. 2341 2342config UNUSED_SYMBOLS 2343 bool "Enable unused/obsolete exported symbols" 2344 default y if X86 2345 help 2346 Unused but exported symbols make the kernel needlessly bigger. For 2347 that reason most of these unused exports will soon be removed. This 2348 option is provided temporarily to provide a transition period in case 2349 some external kernel module needs one of these symbols anyway. If you 2350 encounter such a case in your module, consider if you are actually 2351 using the right API. (rationale: since nobody in the kernel is using 2352 this in a module, there is a pretty good chance it's actually the 2353 wrong interface to use). If you really need the symbol, please send a 2354 mail to the linux kernel mailing list mentioning the symbol and why 2355 you really need it, and what the merge plan to the mainline kernel for 2356 your module is. 2357 2358config TRIM_UNUSED_KSYMS 2359 bool "Trim unused exported kernel symbols" 2360 depends on !UNUSED_SYMBOLS 2361 help 2362 The kernel and some modules make many symbols available for 2363 other modules to use via EXPORT_SYMBOL() and variants. Depending 2364 on the set of modules being selected in your kernel configuration, 2365 many of those exported symbols might never be used. 2366 2367 This option allows for unused exported symbols to be dropped from 2368 the build. In turn, this provides the compiler more opportunities 2369 (especially when using LTO) for optimizing the code and reducing 2370 binary size. This might have some security advantages as well. 2371 2372 If unsure, or if you need to build out-of-tree modules, say N. 2373 2374config UNUSED_KSYMS_WHITELIST 2375 string "Whitelist of symbols to keep in ksymtab" 2376 depends on TRIM_UNUSED_KSYMS 2377 help 2378 By default, all unused exported symbols will be un-exported from the 2379 build when TRIM_UNUSED_KSYMS is selected. 2380 2381 UNUSED_KSYMS_WHITELIST allows to whitelist symbols that must be kept 2382 exported at all times, even in absence of in-tree users. The value to 2383 set here is the path to a text file containing the list of symbols, 2384 one per line. The path can be absolute, or relative to the kernel 2385 source tree. 2386 2387endif # MODULES 2388 2389config MODULES_TREE_LOOKUP 2390 def_bool y 2391 depends on PERF_EVENTS || TRACING 2392 2393config INIT_ALL_POSSIBLE 2394 bool 2395 help 2396 Back when each arch used to define their own cpu_online_mask and 2397 cpu_possible_mask, some of them chose to initialize cpu_possible_mask 2398 with all 1s, and others with all 0s. When they were centralised, 2399 it was better to provide this option than to break all the archs 2400 and have several arch maintainers pursuing me down dark alleys. 2401 2402source "block/Kconfig" 2403 2404config PREEMPT_NOTIFIERS 2405 bool 2406 2407config PADATA 2408 depends on SMP 2409 bool 2410 2411config ASN1 2412 tristate 2413 help 2414 Build a simple ASN.1 grammar compiler that produces a bytecode output 2415 that can be interpreted by the ASN.1 stream decoder and used to 2416 inform it as to what tags are to be expected in a stream and what 2417 functions to call on what tags. 2418 2419source "kernel/Kconfig.locks" 2420 2421config ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE 2422 bool 2423 2424config ARCH_HAS_SYNC_CORE_BEFORE_USERMODE 2425 bool 2426 2427# It may be useful for an architecture to override the definitions of the 2428# SYSCALL_DEFINE() and __SYSCALL_DEFINEx() macros in <linux/syscalls.h> 2429# and the COMPAT_ variants in <linux/compat.h>, in particular to use a 2430# different calling convention for syscalls. They can also override the 2431# macros for not-implemented syscalls in kernel/sys_ni.c and 2432# kernel/time/posix-stubs.c. All these overrides need to be available in 2433# <asm/syscall_wrapper.h>. 2434config ARCH_HAS_SYSCALL_WRAPPER 2435 def_bool n 2436