iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

kvm: x86: mmu: Make NX huge page recovery period configurable

Browse Source 
Currently, the NX huge page recovery thread wakes up every minute and
zaps 1/nx_huge_pages_recovery_ratio of the total number of split NX
huge pages at a time. This is intended to ensure that only a
relatively small number of pages get zapped at a time. But for very
large VMs (or more specifically, VMs with a large number of
executable pages), a period of 1 minute could still result in this
number being too high (unless the ratio is changed significantly,
but that can result in split pages lingering on for too long).

This change makes the period configurable instead of fixing it at
1 minute. Users of large VMs can then adjust the period and/or the
ratio to reduce the number of pages zapped at one time while still
maintaining the same overall duration for cycling through the
entire list. By default, KVM derives a period from the ratio such
that a page will remain on the list for 1 hour on average.

Signed-off-by: Junaid Shahid <junaids@google.com>
Message-Id: <20211020010627.305925-1-junaids@google.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Junaid Shahid 2021-10-19 18:06:27 -07:00 committed by Paolo Bonzini
parent 540c7abe61
commit 4dfe4f40d8
2 changed files with 38 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Documentation/admin-guide/kernel-parameters.txt
View File

@ -2353,7 +2353,14 @@
[KVM] Controls how many 4KiB pages are periodically zapped [KVM] Controls how many 4KiB pages are periodically zapped
back to huge pages. 0 disables the recovery, otherwise if back to huge pages. 0 disables the recovery, otherwise if
the value is N KVM will zap 1/Nth of the 4KiB pages every the value is N KVM will zap 1/Nth of the 4KiB pages every
minute. The default is 60. period (see below). The default is 60.
kvm.nx_huge_pages_recovery_period_ms=
[KVM] Controls the time period at which KVM zaps 4KiB pages
back to huge pages. If the value is a non-zero N, KVM will
zap a portion (see ratio above) of the pages every N msecs.
If the value is 0 (the default), KVM will pick a period based
on the ratio, such that a page is zapped after 1 hour on average.
kvm-amd.nested= [KVM,AMD] Allow nested virtualization in KVM/SVM. kvm-amd.nested= [KVM,AMD] Allow nested virtualization in KVM/SVM.
Default is 1 (enabled) Default is 1 (enabled)

41
arch/x86/kvm/mmu/mmu.c
View File

@ -58,6 +58,7 @@
extern bool itlb_multihit_kvm_mitigation; extern bool itlb_multihit_kvm_mitigation;
int __read_mostly nx_huge_pages = -1; int __read_mostly nx_huge_pages = -1;
static uint __read_mostly nx_huge_pages_recovery_period_ms;
#ifdef CONFIG_PREEMPT_RT #ifdef CONFIG_PREEMPT_RT
/* Recovery can cause latency spikes, disable it for PREEMPT_RT. */ /* Recovery can cause latency spikes, disable it for PREEMPT_RT. */
static uint __read_mostly nx_huge_pages_recovery_ratio = 0; static uint __read_mostly nx_huge_pages_recovery_ratio = 0;
@ -66,23 +67,26 @@ static uint __read_mostly nx_huge_pages_recovery_ratio = 60;
#endif #endif
static int set_nx_huge_pages(const char *val, const struct kernel_param *kp); static int set_nx_huge_pages(const char *val, const struct kernel_param *kp);
static int set_nx_huge_pages_recovery_ratio(const char *val, const struct kernel_param *kp); static int set_nx_huge_pages_recovery_param(const char *val, const struct kernel_param *kp);
static const struct kernel_param_ops nx_huge_pages_ops = { static const struct kernel_param_ops nx_huge_pages_ops = {
.set = set_nx_huge_pages, .set = set_nx_huge_pages,
.get = param_get_bool, .get = param_get_bool,
}; };
static const struct kernel_param_ops nx_huge_pages_recovery_ratio_ops = { static const struct kernel_param_ops nx_huge_pages_recovery_param_ops = {
.set = set_nx_huge_pages_recovery_ratio, .set = set_nx_huge_pages_recovery_param,
.get = param_get_uint, .get = param_get_uint,
}; };
module_param_cb(nx_huge_pages, &nx_huge_pages_ops, &nx_huge_pages, 0644); module_param_cb(nx_huge_pages, &nx_huge_pages_ops, &nx_huge_pages, 0644);
__MODULE_PARM_TYPE(nx_huge_pages, "bool"); __MODULE_PARM_TYPE(nx_huge_pages, "bool");
module_param_cb(nx_huge_pages_recovery_ratio, &nx_huge_pages_recovery_ratio_ops, module_param_cb(nx_huge_pages_recovery_ratio, &nx_huge_pages_recovery_param_ops,
&nx_huge_pages_recovery_ratio, 0644); &nx_huge_pages_recovery_ratio, 0644);
__MODULE_PARM_TYPE(nx_huge_pages_recovery_ratio, "uint"); __MODULE_PARM_TYPE(nx_huge_pages_recovery_ratio, "uint");
module_param_cb(nx_huge_pages_recovery_period_ms, &nx_huge_pages_recovery_param_ops,
&nx_huge_pages_recovery_period_ms, 0644);
__MODULE_PARM_TYPE(nx_huge_pages_recovery_period_ms, "uint");
static bool __read_mostly force_flush_and_sync_on_reuse; static bool __read_mostly force_flush_and_sync_on_reuse;
module_param_named(flush_on_reuse, force_flush_and_sync_on_reuse, bool, 0644); module_param_named(flush_on_reuse, force_flush_and_sync_on_reuse, bool, 0644);
@ -6145,18 +6149,24 @@ void kvm_mmu_module_exit(void)
mmu_audit_disable(); mmu_audit_disable();
} }
static int set_nx_huge_pages_recovery_ratio(const char *val, const struct kernel_param *kp) static int set_nx_huge_pages_recovery_param(const char *val, const struct kernel_param *kp)
{ {
unsigned int old_val; bool was_recovery_enabled, is_recovery_enabled;
uint old_period, new_period;
int err; int err;
old_val = nx_huge_pages_recovery_ratio; was_recovery_enabled = nx_huge_pages_recovery_ratio;
old_period = nx_huge_pages_recovery_period_ms;
err = param_set_uint(val, kp); err = param_set_uint(val, kp);
if (err) if (err)
return err; return err;
if (READ_ONCE(nx_huge_pages) && is_recovery_enabled = nx_huge_pages_recovery_ratio;
!old_val && nx_huge_pages_recovery_ratio) { new_period = nx_huge_pages_recovery_period_ms;
if (READ_ONCE(nx_huge_pages) && is_recovery_enabled &&
(!was_recovery_enabled || old_period > new_period)) {
struct kvm *kvm; struct kvm *kvm;
mutex_lock(&kvm_lock); mutex_lock(&kvm_lock);
@ -6219,8 +6229,17 @@ static void kvm_recover_nx_lpages(struct kvm *kvm)
static long get_nx_lpage_recovery_timeout(u64 start_time) static long get_nx_lpage_recovery_timeout(u64 start_time)
{ {
return READ_ONCE(nx_huge_pages) && READ_ONCE(nx_huge_pages_recovery_ratio) uint ratio = READ_ONCE(nx_huge_pages_recovery_ratio);
? start_time + 60 * HZ - get_jiffies_64() uint period = READ_ONCE(nx_huge_pages_recovery_period_ms);
if (!period && ratio) {
/* Make sure the period is not less than one second. */
ratio = min(ratio, 3600u);
period = 60 * 60 * 1000 / ratio;
}
return READ_ONCE(nx_huge_pages) && ratio
? start_time + msecs_to_jiffies(period) - get_jiffies_64()
: MAX_SCHEDULE_TIMEOUT; : MAX_SCHEDULE_TIMEOUT;
} }