Merge tag 'powerpc-6.6-1' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc...
[sfrench/cifs-2.6.git] / Documentation / admin-guide / kernel-parameters.txt
index fd9f21b4958215f49c4044cb6478feb1c31d0a87..fcf79acea475d49077a7ed7d659387b2c64b0d34 100644 (file)
        arm64.nobti     [ARM64] Unconditionally disable Branch Target
                        Identification support
 
-       arm64.nopauth   [ARM64] Unconditionally disable Pointer Authentication
-                       support
+       arm64.nomops    [ARM64] Unconditionally disable Memory Copy and Memory
+                       Set instructions support
 
        arm64.nomte     [ARM64] Unconditionally disable Memory Tagging Extension
                        support
 
-       arm64.nosve     [ARM64] Unconditionally disable Scalable Vector
-                       Extension support
+       arm64.nopauth   [ARM64] Unconditionally disable Pointer Authentication
+                       support
 
        arm64.nosme     [ARM64] Unconditionally disable Scalable Matrix
                        Extension support
 
-       arm64.nomops    [ARM64] Unconditionally disable Memory Copy and Memory
-                       Set instructions support
+       arm64.nosve     [ARM64] Unconditionally disable Scalable Vector
+                       Extension support
 
        ataflop=        [HW,M68k]
 
                        others).
 
        ccw_timeout_log [S390]
-                       See Documentation/s390/common_io.rst for details.
+                       See Documentation/arch/s390/common_io.rst for details.
 
        cgroup_disable= [KNL] Disable a particular controller or optional feature
                        Format: {name of the controller(s) or feature(s) to disable}
                        Setting checkreqprot to 1 is deprecated.
 
        cio_ignore=     [S390]
-                       See Documentation/s390/common_io.rst for details.
+                       See Documentation/arch/s390/common_io.rst for details.
 
        clearcpuid=X[,X...] [X86]
                        Disable CPUID feature X for the kernel. See
                        kernel/dma/contiguous.c
 
        cma_pernuma=nn[MG]
-                       [ARM64,KNL,CMA]
+                       [KNL,CMA]
                        Sets the size of kernel per-numa memory area for
                        contiguous memory allocations. A value of 0 disables
                        per-numa CMA altogether. And If this option is not
                        which is located in node nid, if the allocation fails,
                        they will fallback to the global default memory area.
 
+       numa_cma=<node>:nn[MG][,<node>:nn[MG]]
+                       [KNL,CMA]
+                       Sets the size of kernel numa memory area for
+                       contiguous memory allocations. It will reserve CMA
+                       area for the specified node.
+
+                       With numa CMA enabled, DMA users on node nid will
+                       first try to allocate buffer from the numa area
+                       which is located in node nid, if the allocation fails,
+                       they will fallback to the global default memory area.
+
        cmo_free_hint=  [PPC] Format: { yes | no }
                        Specify whether pages are marked as being inactive
                        when they are freed.  This is used in CMO environments
                        Format: off | on
                        default: on
 
+       gather_data_sampling=
+                       [X86,INTEL] Control the Gather Data Sampling (GDS)
+                       mitigation.
+
+                       Gather Data Sampling is a hardware vulnerability which
+                       allows unprivileged speculative access to data which was
+                       previously stored in vector registers.
+
+                       This issue is mitigated by default in updated microcode.
+                       The mitigation may have a performance impact but can be
+                       disabled. On systems without the microcode mitigation
+                       disabling AVX serves as a mitigation.
+
+                       force:  Disable AVX to mitigate systems without
+                               microcode mitigation. No effect if the microcode
+                               mitigation is present. Known to cause crashes in
+                               userspace with buggy AVX enumeration.
+
+                       off:    Disable GDS mitigation.
+
        gcov_persist=   [GCOV] When non-zero (default), profiling data for
                        kernel modules is saved and remains accessible via
                        debugfs, even when the module is unloaded/reloaded.
 
        kvm-intel.flexpriority=
                        [KVM,Intel] Control KVM's use of FlexPriority feature
-                       (TPR shadow). Default is 1 (enabled). Disalbe by KVM if
+                       (TPR shadow). Default is 1 (enabled). Disable by KVM if
                        hardware lacks support for it.
 
        kvm-intel.nested=
        locktorture.torture_type= [KNL]
                        Specify the locking implementation to test.
 
+       locktorture.writer_fifo= [KNL]
+                       Run the write-side locktorture kthreads at
+                       sched_set_fifo() real-time priority.
+
        locktorture.verbose= [KNL]
                        Enable additional printk() statements.
 
                        [KNL,SH] Allow user to override the default size for
                        per-device physically contiguous DMA buffers.
 
-       memhp_default_state=online/offline
+       memhp_default_state=online/offline/online_kernel/online_movable
                        [KNL] Set the initial state for the memory hotplug
                        onlining policy. If not specified, the default value is
                        set according to the
                                Disable all optional CPU mitigations.  This
                                improves system performance, but it may also
                                expose users to several CPU vulnerabilities.
-                               Equivalent to: nopti [X86,PPC]
-                                              if nokaslr then kpti=0 [ARM64]
-                                              nospectre_v1 [X86,PPC]
-                                              nobp=0 [S390]
-                                              nospectre_v2 [X86,PPC,S390,ARM64]
-                                              spectre_v2_user=off [X86]
-                                              spec_store_bypass_disable=off [X86,PPC]
-                                              ssbd=force-off [ARM64]
-                                              nospectre_bhb [ARM64]
+                               Equivalent to: if nokaslr then kpti=0 [ARM64]
+                                              gather_data_sampling=off [X86]
+                                              kvm.nx_huge_pages=off [X86]
                                               l1tf=off [X86]
                                               mds=off [X86]
-                                              tsx_async_abort=off [X86]
-                                              kvm.nx_huge_pages=off [X86]
-                                              srbds=off [X86,INTEL]
+                                              mmio_stale_data=off [X86]
                                               no_entry_flush [PPC]
                                               no_uaccess_flush [PPC]
-                                              mmio_stale_data=off [X86]
+                                              nobp=0 [S390]
+                                              nopti [X86,PPC]
+                                              nospectre_bhb [ARM64]
+                                              nospectre_v1 [X86,PPC]
+                                              nospectre_v2 [X86,PPC,S390,ARM64]
                                               retbleed=off [X86]
+                                              spec_store_bypass_disable=off [X86,PPC]
+                                              spectre_v2_user=off [X86]
+                                              srbds=off [X86,INTEL]
+                                              ssbd=force-off [ARM64]
+                                              tsx_async_abort=off [X86]
 
                                Exceptions:
                                               This does not have any effect on
                        timeout < 0: reboot immediately
                        Format: <timeout>
 
-       panic_print=    Bitmask for printing system info when panic happens.
-                       User can chose combination of the following bits:
-                       bit 0: print all tasks info
-                       bit 1: print system memory info
-                       bit 2: print timer info
-                       bit 3: print locks info if CONFIG_LOCKDEP is on
-                       bit 4: print ftrace buffer
-                       bit 5: print all printk messages in buffer
-                       bit 6: print all CPUs backtrace (if available in the arch)
-                       *Be aware* that this option may print a _lot_ of lines,
-                       so there are risks of losing older messages in the log.
-                       Use this option carefully, maybe worth to setup a
-                       bigger log buffer with "log_buf_len" along with this.
-
        panic_on_taint= Bitmask for conditionally calling panic() in add_taint()
                        Format: <hex>[,nousertaint]
                        Hexadecimal bitmask representing the set of TAINT flags
        panic_on_warn=1 panic() instead of WARN().  Useful to cause kdump
                        on a WARN().
 
+       panic_print=    Bitmask for printing system info when panic happens.
+                       User can chose combination of the following bits:
+                       bit 0: print all tasks info
+                       bit 1: print system memory info
+                       bit 2: print timer info
+                       bit 3: print locks info if CONFIG_LOCKDEP is on
+                       bit 4: print ftrace buffer
+                       bit 5: print all printk messages in buffer
+                       bit 6: print all CPUs backtrace (if available in the arch)
+                       *Be aware* that this option may print a _lot_ of lines,
+                       so there are risks of losing older messages in the log.
+                       Use this option carefully, maybe worth to setup a
+                       bigger log buffer with "log_buf_len" along with this.
+
        parkbd.port=    [HW] Parallel port number the keyboard adapter is
                        connected to, default is 0.
                        Format: <parport#>
                        mode 0, bit 1 is for mode 1, and so on.  Mode 0 only
                        allowed by default.
 
-       pause_on_oops=
+       pause_on_oops=<int>
                        Halt all CPUs after the first oops has been printed for
                        the specified number of seconds.  This is to be used if
                        your oopses keep scrolling off the screen.
                        test until boot completes in order to avoid
                        interference.
 
+       rcuscale.kfree_by_call_rcu= [KNL]
+                       In kernels built with CONFIG_RCU_LAZY=y, test
+                       call_rcu() instead of kfree_rcu().
+
+       rcuscale.kfree_mult= [KNL]
+                       Instead of allocating an object of size kfree_obj,
+                       allocate one of kfree_mult * sizeof(kfree_obj).
+                       Defaults to 1.
+
        rcuscale.kfree_rcu_test= [KNL]
                        Set to measure performance of kfree_rcu() flooding.
 
                        Number of loops doing rcuscale.kfree_alloc_num number
                        of allocations and frees.
 
+       rcuscale.minruntime= [KNL]
+                       Set the minimum test run time in seconds.  This
+                       does not affect the data-collection interval,
+                       but instead allows better measurement of things
+                       like CPU consumption.
+
        rcuscale.nreaders= [KNL]
                        Set number of RCU readers.  The value -1 selects
                        N, where N is the number of CPUs.  A value
                        the same as for rcuscale.nreaders.
                        N, where N is the number of CPUs
 
-       rcuscale.perf_type= [KNL]
+       rcuscale.scale_type= [KNL]
                        Specify the RCU implementation to test.
 
        rcuscale.shutdown= [KNL]
                        in microseconds.  The default of zero says
                        no holdoff.
 
+       rcuscale.writer_holdoff_jiffies= [KNL]
+                       Additional write-side holdoff between grace
+                       periods, but in jiffies.  The default of zero
+                       says no holdoff.
+
        rcutorture.fqs_duration= [KNL]
                        Set duration of force_quiescent_state bursts
                        in microseconds.
                        number avoids disturbing real-time workloads,
                        but lengthens grace periods.
 
+       rcupdate.rcu_task_lazy_lim= [KNL]
+                       Number of callbacks on a given CPU that will
+                       cancel laziness on that CPU.  Use -1 to disable
+                       cancellation of laziness, but be advised that
+                       doing so increases the danger of OOM due to
+                       callback flooding.
+
        rcupdate.rcu_task_stall_info= [KNL]
                        Set initial timeout in jiffies for RCU task stall
                        informational messages, which give some indication
                        A change in value does not take effect until
                        the beginning of the next grace period.
 
+       rcupdate.rcu_tasks_lazy_ms= [KNL]
+                       Set timeout in milliseconds RCU Tasks asynchronous
+                       callback batching for call_rcu_tasks().
+                       A negative value will take the default.  A value
+                       of zero will disable batching.  Batching is
+                       always disabled for synchronize_rcu_tasks().
+
+       rcupdate.rcu_tasks_rude_lazy_ms= [KNL]
+                       Set timeout in milliseconds RCU Tasks
+                       Rude asynchronous callback batching for
+                       call_rcu_tasks_rude().  A negative value
+                       will take the default.  A value of zero will
+                       disable batching.  Batching is always disabled
+                       for synchronize_rcu_tasks_rude().
+
+       rcupdate.rcu_tasks_trace_lazy_ms= [KNL]
+                       Set timeout in milliseconds RCU Tasks
+                       Trace asynchronous callback batching for
+                       call_rcu_tasks_trace().  A negative value
+                       will take the default.  A value of zero will
+                       disable batching.  Batching is always disabled
+                       for synchronize_rcu_tasks_trace().
+
        rcupdate.rcu_self_test= [KNL]
                        Run the RCU early boot self tests
 
                        Useful for devices that are detected asynchronously
                        (e.g. USB and MMC devices).
 
+       rootwait=       [KNL] Maximum time (in seconds) to wait for root device
+                       to show up before attempting to mount the root
+                       filesystem.
+
        rproc_mem=nn[KMG][@address]
                        [KNL,ARM,CMA] Remoteproc physical memory block.
                        Memory area to be used by remote processor image,
                        Not specifying this option is equivalent to
                        spectre_v2_user=auto.
 
+       spec_rstack_overflow=
+                       [X86] Control RAS overflow mitigation on AMD Zen CPUs
+
+                       off             - Disable mitigation
+                       microcode       - Enable microcode mitigation only
+                       safe-ret        - Enable sw-only safe RET mitigation (default)
+                       ibpb            - Enable mitigation by issuing IBPB on
+                                         kernel entry
+                       ibpb-vmexit     - Issue IBPB only on VMEXIT
+                                         (cloud-specific mitigation)
+
        spec_store_bypass_disable=
                        [HW] Control Speculative Store Bypass (SSB) Disable mitigation
                        (Speculative Store Bypass vulnerability)
                        -1: disable all critical trip points in all thermal zones
                        <degrees C>: override all critical trip points
 
-       thermal.nocrt=  [HW,ACPI]
-                       Set to disable actions on ACPI thermal zone
-                       critical and hot trip points.
-
        thermal.off=    [HW,ACPI]
                        1: disable ACPI thermal control
 
                        This will guarantee that all the other pcrs
                        are saved.
 
+       tpm_tis.interrupts= [HW,TPM]
+                       Enable interrupts for the MMIO based physical layer
+                       for the FIFO interface. By default it is set to false
+                       (0). For more information about TPM hardware interfaces
+                       defined by Trusted Computing Group (TCG) see
+                       https://trustedcomputinggroup.org/resource/pc-client-platform-tpm-profile-ptp-specification/
+
        tp_printk       [FTRACE]
                        Have the tracepoints sent to printk as well as the
                        tracing ring buffer. This is useful for early boot up