Merge tag 'dma-mapping-6.6-2023-08-29' of git://git.infradead.org/users/hch/dma-mapping
[platform/kernel/linux-rpi.git] / Documentation / admin-guide / kernel-parameters.txt
index 87ad815..93f646e 100644 (file)
                        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
                        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.
        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.
 
                                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
                        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