Chapter 5. Important changes to external kernel parameters

This chapter provides system administrators with a summary of significant changes in the kernel shipped with Red Hat Enterprise Linux 8.5. These changes could include for example added or updated proc entries, sysctl, and sysfs default values, boot parameters, kernel configuration options, or any noticeable behavior changes.

New kernel parameters

idxd.sva = [HW]

Format: <bool>

With this parameter you can force disable Shared Virtual Memory (SVA) support for the idxd kernel module.

The default value is true (1).

lsm.debug = [SECURITY]
With this parameter you can enable Linux Security Module (LSM) initialization debugging output.
lsm = lsm1,…​,lsmN [SECURITY]

With this parameter you can choose the order of Linux Security Module (LSM) initialization.

This parameter overrides CONFIG_LSM option, and the security= parameter.

rcutree.qovld = [KNL]

With this parameter you can set a threshold of queued Read-copy-update (RCU) callbacks. Beyond this threshold, RCU’s force-quiescent-state scan will aggressively enlist help from the cond_resched() system call and schedule IPIs to help CPUs reach more quickly quiescent states.

You can set this parameter to values smaller than zero to make this parameter be set based on the rcutree.qhimark parameter at boot time. Alternatively, set this parameter to zero to disable more aggressive help enlistment.

rcutree.rcu_unlock_delay = [KNL]

With this parameter you can specify the rcu_read_unlock()-time delay, in kernels where the config boolean is set to CONFIG_RCU_STRICT_GRACE_PERIOD=y.

The default value is 0.

Larger delays increase the probability of catching Read-copy-update (RCU) pointer leaks. That is a flawed use of RCU-protected pointers after the relevant rcu_read_unlock() has completed.

rcutorture.irqreader = [KNL]
With this parameter you can run Read-copy-update (RCU) readers from Interrupt request (IRQ) handlers, or from a timer handler.
rcutorture.leakpointer = [KNL]
With this parameter you can leak a Read-copy-update (RCU) protected pointer out of the reader. This can result in splats, and is intended to test the ability of configurations such as CONFIG_RCU_STRICT_GRACE_PERIOD=y to detect such leaks.
rcutorture.read_exit = [KNL]
With this parameter you can set the number of read-then-exit kthreads to test the interaction of Read-copy-update (RCU) updaters and task-exit processing.
rcutorture.read_exit_burst = [KNL]
With this parameter you can specify the number of times in a given read-then-exit episode that a set of read-then-exit kthreads is spawned.
rcutorture.read_exit_delay = [KNL]
With this parameter you can specify the delay, in seconds, between successive read-then-exit testing episodes.
rcutorture.stall_cpu_block = [KNL]
With this parameter you can set sleep while stalling. As a result, warnings from pre-emptible Read-copy-update (RCU) in addition to any other stall-related activity can occur.
rcutorture.stall_gp_kthread = [KNL]

With this parameter you can specify duration, in seconds, of forced sleep within Read-copy-update (RCU) grace-period kthread to test RCU CPU stall warnings.

Set this parameter to zero to disable the functionality.

If both stall_cpu and stall_gp_kthread parameters are specified, the kthread is starved first, then the CPU.

rcupdate.rcu_cpu_stall_suppress_at_boot = [KNL]
With this parameter you can suppress RCU CPU stall warning messages and rcutorture writer stall warnings that occur during early boot. That is during the time before the init task is spawned.
rcupdate.rcu_task_ipi_delay = [KNL]

With this parameter you can set time in jiffies during which Read-copy-update (RCU) tasks avoid sending IPIs, starting with the beginning of a given grace period.

Setting a large number avoids disturbing real-time workloads, but lengthens grace periods.

refscale.holdoff = [KNL]
With this parameter you can set test-start holdoff period. The purpose of this parameter is to delay the start of the test until boot completes in order to avoid interference.
refscale.loops = [KNL]

With this parameter you can set the number of loops over the synchronization primitive under test. Increasing this number reduces noise due to loop start/end overhead.

The default value has already reduced the per-pass noise to a handful of picoseconds on about 2020 x86 laptops.

refscale.nreaders = [KNL]

With this parameter you can set the number of readers.

The default value of -1 selects N, where N is roughly 75% of the number of CPUs.

refscale.nruns = [KNL]
With this parameter you can set the number of runs, each of which is dumped onto the console log.
refscale.readdelay = [KNL]
With this parameter you can set the read-side critical-section duration, measured in microseconds.
refscale.scale_type = [KNL]
With this parameter you can specify the read-protection implementation to test.
refscale.shutdown = [KNL]

With this parameter you can shut down the system at the end of the performance test.

The default value is 1 and it shuts down the system - refscale is built into the kernel.

The value 0 and leaves the system running - refscale is built as a module.

refscale.verbose = [KNL]
With this parameter you can enable additional printk() statements.
scftorture.holdoff = [KNL]

With this parameter you can specify the number of seconds to hold off before starting test.

The paramter defaults to zero for module insertion and to 10 seconds for built-in smp_call_function() tests.

scftorture.longwait = [KNL]

With this parameter you can request very long waits, which are randomly selected up to the chosen limit in seconds.

The default value is zero and it disables this feature.

Note that requesting even small non-zero numbers of seconds can result in Read-copy-update (RCU) CPU stall warnings, softlockup complaints, and so on.

scftorture.nthreads = [KNL]

With this parameter you can specify the number of kthreads to spawn to invoke the smp_call_function() family of functions.

The default of -1 specifies a number of kthreads equal to the number of CPUs.

scftorture.onoff_holdoff = [KNL]
With this parameter you can specify the number of seconds to wait after the start of the test before initiating CPU-hotplug operations.
scftorture.onoff_interval = [KNL]

With this parameter you can specify the number of seconds to wait between successive CPU-hotplug operations.

The default value is zero and it disables CPU-hotplug operations.

scftorture.shutdown_secs = [KNL]

With this parameter you can specify the number of seconds following the start of the test. After the test the system shuts down.

With the default value of zero you can avoid shutting down the system. Non-zero values are useful for automated tests.

scftorture.stat_interval = [KNL]

With this parameter you can specify the number of seconds between outputting the current test statistics to the console.

A value of zero disables statistics output.

scftorture.stutter_cpus = [KNL]
With this parameter you can specify the number of jiffies to wait between each change to the set of CPUs under test.
scftorture.use_cpus_read_lock = [KNL]
With this parameter you can use the use_cpus_read_lock() system call instead of the default preempt_disable() system call to disable CPU hotplug while invoking one of the smp_call_function*() functions.
scftorture.verbose = [KNL]
With this parameter you can enable additional printk() statements.
scftorture.weight_single = [KNL]

This parameter specifies the probability weighting to use for the smp_call_function_single() function with a zero "wait" parameter.

A value of -1 selects the default if all other weights are -1. However, if at least one weight has some other value, a value of -1 will instead select a weight of zero.

scftorture.weight_single_wait = [KNL]
This parameter specifies the probability weighting to use for the smp_call_function_single() function with a non-zero "wait" parameter. For more information see weight_single.
scftorture.weight_many = [KNL]

This parameter specifies the probability weighting to use for the smp_call_function_many() function with a zero "wait" parameter.

Note that setting a high probability for this weighting can place serious Inter-processor Interrupt (IPI) load on the system.

For more information see weight_single.

scftorture.weight_many_wait = [KNL]

This parameter specifies the probability weighting to use for the smp_call_function_many() function with a non-zero "wait" parameter.

For more information see weight_single and weight_many.

scftorture.weight_all = [KNL]

This parameter specifies the probability weighting to use for the smp_call_function_all() function with a zero "wait" parameter.

For more information see weight_single and weight_many.

scftorture.weight_all_wait = [KNL]

This parameter specifies the probability weighting to use for the smp_call_function_all() function with a non-zero "wait" parameter.

For more information see weight_single and weight_many.

torture.disable_onoff_at_boot = [KNL]
With this parameter you can prevent the CPU-hotplug component of torturing until after the init task has spawned.
torture.ftrace_dump_at_shutdown = [KNL]

With this parameter you can dump the ftrace buffer at torture-test shutdown, even if there were no errors.

This can be a very costly operation when many torture tests are running concurrently, especially on systems with rotating-rust storage.

Updated kernel parameters

iommu.forcedac = [ARM64, X86]

With this parameter you can control input-output virtual address (IOVA) allocation for PCI devices.

Format: { 0 | 1 }

  • 0 - Try to allocate a 32-bit Direct Memory Access (DMA) address first, before falling back to the full range if needed.
  • 1 - Allocate directly from the full usable range. The option is forcing Dual Address Cycle for PCI cards which support greater than 32-bit addressing.
page_poison = [KNL]

With this boot-time parameter you can change the state of poisoning on the buddy allocator, available with the CONFIG_PAGE_POISONING=y configuration.

  • off: turn off poisoning (default)
  • on: turn on poisoning
rcuscale.gp_async = [KNL]
With this parameter you can measure performance of asynchronous grace-period primitives such as call_rcu().
rcuscale.gp_async_max = [KNL]
With this parameter you can specify the maximum number of outstanding callbacks per writer thread. When a writer thread exceeds this limit, it invokes the corresponding flavor of rcu_barrier() to allow previously posted callbacks to drain.
rcuscale.gp_exp = [KNL]
With this parameter you can measure the performance of expedited synchronous grace-period primitives.
rcuscale.holdoff = [KNL]
With this parameter you can set test-start holdoff period. The purpose of this parameter is to delay the start of the test until boot completes in order to avoid interference.
rcuscale.kfree_rcu_test = [KNL]
With this parameter you can measure performance of kfree_rcu() flooding.
rcuscale.kfree_nthreads = [KNL]
With this parameter you can specify the number of threads running loops of the kfree_rcu() function.
rcuscale.kfree_alloc_num = [KNL]
With this parameter you can specify the number of allocations and frees done in an iteration.
rcuscale.kfree_loops = [KNL]
With this parameter you can specify the number of loops doing rcuscale.kfree_alloc_num number of allocations and frees.
rcuscale.nreaders = [KNL]

With this parameter you can set the number of Read-copy-update (RCU) readers.

The value -1 selects N, where N is the number of CPUs.

rcuscale.nwriters = [KNL]

With this parameter you can set the number of Read-copy-update (RCU) writers.

The values operate the same as for rcuscale.nreaders=N, where N is the number of CPUs.

rcuscale.perf_type = [KNL]
With this parameter you can specify the Read-copy-update (RCU) implementation to test.
rcuscale.shutdown = [KNL]
With this parameter you can shut the system down after performance tests complete. This is useful for hands-off automated testing.
rcuscale.verbose = [KNL]
With this parameter you can enable additional printk() statements.
rcuscale.writer_holdoff = [KNL]

With this parameter you can write-side holdoff between grace periods in microseconds.

The default value is zero and it means "no holdoff".

security = [SECURITY]

With this parameter you can choose a legacy "major" security module to be enabled at boot.

This has been deprecated by the lsm parameter.

split_lock_detect = [X86]

With this parameter you can enable split lock detection or bus lock detection.

When enabled, and if hardware support is present, atomic instructions that access data across cache line boundaries will result in:

  • an alignment check exception for split lock detection
  • a debug exception for bus lock detection

    Possible values:

  • off - the functionality is not enabled
  • warn - the kernel emits rate-limited warnings about applications and trigger the #AC exception or the #DB exception. This mode is the default on CPUs that support the split lock detection or the bus lock detection. The default behavior is by #AC if both features are enabled in hardware.
  • fatal - the kernel sends the SIGBUS signal to applications that trigger the #AC exception or the #DB exception. The default behavior is by #AC if both features are enabled in hardware.
  • ratelimit:N - sets the system wide rate limit to N bus locks per second for bus lock detection (0 < N ⇐ 1000). N/A for split lock detection.

    If an #AC exception is hit in the kernel or in firmware (for example not while executing in user mode) the kernel will oops in either the warn or fatal mode.

    #DB exception for bus lock is triggered only when CPL > 0.

usb-storage.quirks =
k = NO_SAME (do not use WRITE_SAME, UAS only)