]> git.ipfire.org Git - thirdparty/kernel/stable.git/blobdiff - Documentation/admin-guide/kernel-parameters.txt
Merge tag 'powerpc-4.21-1' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc...
[thirdparty/kernel/stable.git] / Documentation / admin-guide / kernel-parameters.txt
index 495adb66148c2e6282e80b66f83fba639dc21374..ff4daa780ae8b1653b146bdc1bbf669741c09ec7 100644 (file)
        cpuidle.off=1   [CPU_IDLE]
                        disable the cpuidle sub-system
 
+       cpuidle.governor=
+                       [CPU_IDLE] Name of the cpuidle governor to use.
+
        cpufreq.off=1   [CPU_FREQ]
                        disable the cpufreq sub-system
 
                        causing system reset or hang due to sending
                        INIT from AP to BSP.
 
-       disable_counter_freezing [HW]
+       perf_v4_pmi=    [X86,INTEL]
+                       Format: <bool>
                        Disable Intel PMU counter freezing feature.
                        The feature only exists starting from
                        Arch Perfmon v4 (Skylake and newer).
                        off
                                Disables hypervisor mitigations and doesn't
                                emit any warnings.
+                               It also drops the swap size and available
+                               RAM limit restriction on both hypervisor and
+                               bare metal.
 
                        Default is 'flush'.
 
                        before loading.
                        See Documentation/blockdev/ramdisk.txt.
 
+       psi=            [KNL] Enable or disable pressure stall information
+                       tracking.
+                       Format: <bool>
+
        psmouse.proto=  [HW,MOUSE] Highest PS2 mouse protocol extension to
                        probe for; one of (bare|imps|exps|lifebook|any).
        psmouse.rate=   [HW,MOUSE] Set desired mouse report rate, in reports
                        in microseconds.  The default of zero says
                        no holdoff.
 
-       rcutorture.cbflood_inter_holdoff= [KNL]
-                       Set holdoff time (jiffies) between successive
-                       callback-flood tests.
-
-       rcutorture.cbflood_intra_holdoff= [KNL]
-                       Set holdoff time (jiffies) between successive
-                       bursts of callbacks within a given callback-flood
-                       test.
-
-       rcutorture.cbflood_n_burst= [KNL]
-                       Set the number of bursts making up a given
-                       callback-flood test.  Set this to zero to
-                       disable callback-flood testing.
-
-       rcutorture.cbflood_n_per_burst= [KNL]
-                       Set the number of callbacks to be registered
-                       in a given burst of a callback-flood test.
-
        rcutorture.fqs_duration= [KNL]
                        Set duration of force_quiescent_state bursts
                        in microseconds.
                        Set wait time between force_quiescent_state bursts
                        in seconds.
 
+       rcutorture.fwd_progress= [KNL]
+                       Enable RCU grace-period forward-progress testing
+                       for the types of RCU supporting this notion.
+
+       rcutorture.fwd_progress_div= [KNL]
+                       Specify the fraction of a CPU-stall-warning
+                       period to do tight-loop forward-progress testing.
+
+       rcutorture.fwd_progress_holdoff= [KNL]
+                       Number of seconds to wait between successive
+                       forward-progress tests.
+
+       rcutorture.fwd_progress_need_resched= [KNL]
+                       Enclose cond_resched() calls within checks for
+                       need_resched() during tight-loop forward-progress
+                       testing.
+
        rcutorture.gp_cond= [KNL]
                        Use conditional/asynchronous update-side
                        primitives, if available.
 
        spectre_v2=     [X86] Control mitigation of Spectre variant 2
                        (indirect branch speculation) vulnerability.
+                       The default operation protects the kernel from
+                       user space attacks.
 
-                       on   - unconditionally enable
-                       off  - unconditionally disable
+                       on   - unconditionally enable, implies
+                              spectre_v2_user=on
+                       off  - unconditionally disable, implies
+                              spectre_v2_user=off
                        auto - kernel detects whether your CPU model is
                               vulnerable
 
                        CONFIG_RETPOLINE configuration option, and the
                        compiler with which the kernel was built.
 
+                       Selecting 'on' will also enable the mitigation
+                       against user space to user space task attacks.
+
+                       Selecting 'off' will disable both the kernel and
+                       the user space protections.
+
                        Specific mitigations can also be selected manually:
 
                        retpoline         - replace indirect branches
                        Not specifying this option is equivalent to
                        spectre_v2=auto.
 
+       spectre_v2_user=
+                       [X86] Control mitigation of Spectre variant 2
+                       (indirect branch speculation) vulnerability between
+                       user space tasks
+
+                       on      - Unconditionally enable mitigations. Is
+                                 enforced by spectre_v2=on
+
+                       off     - Unconditionally disable mitigations. Is
+                                 enforced by spectre_v2=off
+
+                       prctl   - Indirect branch speculation is enabled,
+                                 but mitigation can be enabled via prctl
+                                 per thread.  The mitigation control state
+                                 is inherited on fork.
+
+                       prctl,ibpb
+                               - Like "prctl" above, but only STIBP is
+                                 controlled per thread. IBPB is issued
+                                 always when switching between different user
+                                 space processes.
+
+                       seccomp
+                               - Same as "prctl" above, but all seccomp
+                                 threads will enable the mitigation unless
+                                 they explicitly opt out.
+
+                       seccomp,ibpb
+                               - Like "seccomp" above, but only STIBP is
+                                 controlled per thread. IBPB is issued
+                                 always when switching between different
+                                 user space processes.
+
+                       auto    - Kernel selects the mitigation depending on
+                                 the available CPU features and vulnerability.
+
+                       Default mitigation:
+                       If CONFIG_SECCOMP=y then "seccomp", otherwise "prctl"
+
+                       Not specifying this option is equivalent to
+                       spectre_v2_user=auto.
+
        spec_store_bypass_disable=
                        [HW] Control Speculative Store Bypass (SSB) Disable mitigation
                        (Speculative Store Bypass vulnerability)
                                        prevent spurious wakeup);
                                n = USB_QUIRK_DELAY_CTRL_MSG (Device needs a
                                        pause after every control message);
+                               o = USB_QUIRK_HUB_SLOW_RESET (Hub needs extra
+                                       delay after resetting its port);
                        Example: quirks=0781:5580:bk,0a5c:5834:gij
 
        usbhid.mousepoll=