KVM: Fix use-after-free in debugfs
v3 cover KVM: Fix use-after-free in debugfs
Funny enough, dirty_log_perf_test on arm64 highlights some issues around the use of debugfs in KVM. The test leaks a GIC FD across test iterations, and as such the associated VM is never destroyed. Nonetheless, the VM FD is reused for the next VM, which collides with the old debugfs directory.
Where things get off is when the vgic-state debugfs file is created. KVM does not check if the VM directory exists before creating the file, which results in the file being added to the root of debugfs when the aforementioned collision occurs.
Since KVM relies on deleting the VM directory to clean up all associated files, the errant vgic-state file never gets cleaned up. Poking the file after the VM is destroyed is a use-after-free :)
Patch 1 shuts the door on any mistaken debugfs file creations by initializing kvm->debugfs_dentry with ERR_PTR() instead of NULL.
The last two patches ensure the GIC FD actually gets closed by the selftests that use it. Patch 2 is a genuine bug fix since it will create multiple VMs for a single test run. The arch_timer test also happens to leak the GIC FD, though it is benign since the test creates a single VM. Patch 3 gets the arch_timer test to follow the well-behaved pattern.
Applies cleanly to 5.18-rc1.
Tested on an Ampere Altra system in the following combinations:
- Bad kernel + fixed selftests
- Fixed kernel + bad selftests
In both cases there was no vgic-state file at the root of debugfs. Additionally, I made sure the VM debugfs directory was in fact cleaned up at exit.
v1: https://lore.kernel.org/kvm/[email protected]/
v2: https://lore.kernel.org/kvm/[email protected]/
v2 -> v3:
- Fix error checking in kvm_destroy_vm_debugfs(). Embarrassingly, v2 worsened the bug by not cleaning up the VM directory... (Marc)
v1 -> v2:
- Initialize kvm->debugfs_dentry to ERR_PTR(-ENOENT) to prevent the creation of all VM debug files, not just vgic-state.
- Leave logging as-is for now. Consider dropping altogether in a later patch (Sean)
- Collect R-b from Jing
Oliver Upton (3):
KVM: Don't create VM debugfs files outside of the VM directory
selftests: KVM: Don't leak GIC FD across dirty log test iterations
selftests: KVM: Free the GIC FD when cleaning up in arch_timer
.../selftests/kvm/aarch64/arch_timer.c | 15 +++++--- .../selftests/kvm/dirty_log_perf_test.c | 34 +++++++++++++++++-- virt/kvm/kvm_main.c | 10 ++++-- 3 files changed, 50 insertions(+), 9 deletions(-)
Signature · 6 lines
2.35.1.1094.g7c7d902a7c-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 1/3 KVM: Don't create VM debugfs files outside of the VM directory
Unfortunately, there is no guarantee that KVM was able to instantiate a debugfs directory for a particular VM. To that end, KVM shouldn't even attempt to create new debugfs files in this case. If the specified parent dentry is NULL, debugfs_create_file() will instantiate files at the root of debugfs.
For arm64, it is possible to create the vgic-state file outside of a VM directory, the file is not cleaned up when a VM is destroyed. Nonetheless, the corresponding struct kvm is freed when the VM is destroyed.
Nip the problem in the bud for all possible errant debugfs file creations by initializing kvm->debugfs_dentry to -ENOENT. In so doing, debugfs_create_file() will fail instead of creating the file in the root directory.
--- virt/kvm/kvm_main.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
virt/kvm/kvm_main.c +8 -2
@@ -932,7 +932,7 @@ static void kvm_destroy_vm_debugfs(struct kvm *kvm)int kvm_debugfs_num_entries = kvm_vm_stats_header.num_desc + kvm_vcpu_stats_header.num_desc; -if (!kvm->debugfs_dentry) +if (IS_ERR (kvm->debugfs_dentry))return ;debugfs_remove_recursive (kvm->debugfs_dentry);
@@ -955,6 +955,12 @@ static int kvm_create_vm_debugfs(struct kvm *kvm, int fd)int kvm_debugfs_num_entries = kvm_vm_stats_header.num_desc + kvm_vcpu_stats_header.num_desc; +/* +* Force subsequent debugfs file creations to fail if the VM directory +* is not created. +*/ + kvm->debugfs_dentry =ERR_PTR (-ENOENT ); +if (!debugfs_initialized ())return 0 ;
@@ -5479,7 +5485,7 @@ static void kvm_uevent_notify_change(unsigned int type, struct kvm *kvm) }add_uevent_var (env,"PID=%d" , kvm->userspace_pid); -if (kvm->debugfs_dentry) { +if (!IS_ERR (kvm->debugfs_dentry)) {char *tmp, *p =kmalloc (PATH_MAX ,GFP_KERNEL_ACCOUNT );if (p) {
Signature · 6 lines
2.35.1.1094.g7c7d902a7c-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 2/3 selftests: KVM: Don't leak GIC FD across dirty log test iterations
In reply to Oliver Uptondirty_log_perf_test instantiates a VGICv3 for the guest (if supported by hardware) to reduce the overhead of guest exits. However, the test does not actually close the GIC fd when cleaning up the VM between test iterations, meaning that the VM is never actually destroyed in the kernel.
While this is generally a bad idea, the bug was detected from the kernel spewing about duplicate debugfs entries as subsequent VMs happen to reuse the same FD even though the debugfs directory is still present.
Abstract away the notion of setup/cleanup of the GIC FD from the test by creating arch-specific helpers for test setup/cleanup. Close the GIC FD on VM cleanup and do nothing for the other architectures.
--- .../selftests/kvm/dirty_log_perf_test.c | 34 +++++++++++++++++-- 1 file changed, 31 insertions(+), 3 deletions(-)
tools/testing/selftests/kvm/dirty_log_perf_test.c +31 -3
@@ -18,11 +18,40 @@#include "test_util.h" #include "perf_test_util.h" #include "guest_modes.h" +#ifdef __aarch64__#include "aarch64/vgic.h" #define GICD_BASE_GPA 0x8000000ULL#define GICR_BASE_GPA 0x80A0000ULL + +static int gic_fd; + +static void arch_setup_vm (struct kvm_vm *vm,unsigned int nr_vcpus) +{ +/* +* The test can still run even if hardware does not support GICv3, as it +* is only an optimization to reduce guest exits. +*/ + gic_fd =vgic_v3_setup (vm, nr_vcpus,64 ,GICD_BASE_GPA ,GICR_BASE_GPA ); +} + +static void arch_cleanup_vm (struct kvm_vm *vm) +{ +if (gic_fd >0 ) +close (gic_fd); +} + +#else /* __aarch64__ */ + +static void arch_setup_vm (struct kvm_vm *vm,unsigned int nr_vcpus) +{ +} + +static void arch_cleanup_vm (struct kvm_vm *vm) +{ +} +#endif /* How many host loops to run by default (one KVM_GET_DIRTY_LOG for each loop)*/
@@ -206,9 +235,7 @@ static void run_test(enum vm_guest_mode mode, void *arg)vm_enable_cap (vm, &cap); } -#ifdef __aarch64__ -vgic_v3_setup (vm, nr_vcpus,64 ,GICD_BASE_GPA ,GICR_BASE_GPA ); -#endif +arch_setup_vm (vm, nr_vcpus);/* Start the iterations */ iteration =0 ;
@@ -302,6 +329,7 @@ static void run_test(enum vm_guest_mode mode, void *arg) }free_bitmaps (bitmaps, p->slots); +arch_cleanup_vm (vm);perf_test_destroy_vm (vm); }
Signature · 6 lines
2.35.1.1094.g7c7d902a7c-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 3/3 selftests: KVM: Free the GIC FD when cleaning up in arch_timer
In reply to Oliver UptonIn order to correctly destroy a VM, all references to the VM must be freed. The arch_timer selftest creates a VGIC for the guest, which itself holds a reference to the VM.
Close the GIC FD when cleaning up a VM.
--- tools/testing/selftests/kvm/aarch64/arch_timer.c | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-)
tools/testing/selftests/kvm/aarch64/arch_timer.c +11 -4
@@ -362,11 +362,12 @@ static void test_init_timer_irq(struct kvm_vm *vm)pr_debug ("ptimer_irq: %d; vtimer_irq: %d\n" , ptimer_irq, vtimer_irq); } +static int gic_fd; +static struct kvm_vm *test_vm_create (void ) {struct kvm_vm *vm;unsigned int i; -int ret;int nr_vcpus = test_args.nr_vcpus; vm =vm_create_default_with_vcpus (nr_vcpus,0 ,0 , guest_code,NULL );
@@ -383,8 +384,8 @@ static struct kvm_vm *test_vm_create(void)ucall_init (vm,NULL );test_init_timer_irq (vm); - ret =vgic_v3_setup (vm, nr_vcpus,64 ,GICD_BASE_GPA ,GICR_BASE_GPA ); -if (ret <0 ) { + gic_fd =vgic_v3_setup (vm, nr_vcpus,64 ,GICD_BASE_GPA ,GICR_BASE_GPA ); +if (gic_fd <0 ) {print_skip ("Failed to create vgic-v3" );exit (KSFT_SKIP ); }
@@ -395,6 +396,12 @@ static struct kvm_vm *test_vm_create(void)return vm; } +static void test_vm_cleanup (struct kvm_vm *vm) +{ +close (gic_fd); +kvm_vm_free (vm); +} +static void test_print_help (char *name) { pr_info("Usage: %s [-h] [-n nr_vcpus] [-i iterations] [-p timer_period_ms]\n",
@@ -478,7 +485,7 @@ int main(int argc, char *argv[]) vm =test_vm_create ();test_run (vm); -kvm_vm_free (vm); +test_vm_cleanup (vm);return 0 ; }
Signature · 1 line
2.35.1.1094.g7c7d902a7c-goog
Quoted 6 lines · Oliver Upton
Funny enough,
dirty_log_perf_teston arm64 highlights some issues around the use of debugfs in KVM. The test leaks a GIC FD across test iterations, and as such the associated VM is never destroyed. Nonetheless, the VM FD is reused for the next VM, which collides with the old debugfs directory.
Quoted 6 lines
Where things get off is when the vgic-state debugfs file is created. KVM does not check if the VM directory exists before creating the file, which results in the file being added to the root of debugfs when the aforementioned collision occurs.
[...]
Applied to fixes, thanks!
[1/3] KVM: Don't create VM debugfs files outside of the VM directory
commit: a44a4cc1c969afec97dbb2aedaf6f38eaa6253bb
[2/3] selftests: KVM: Don't leak GIC FD across dirty log test iterations
commit: 386ba265a8197716076a88853244f4437b92b167
[3/3] selftests: KVM: Free the GIC FD when cleaning up in arch_timer
commit: 21db83846683d3987666505a3ec38f367708199aCheers,
M.
Signature · 7 lines
Without deviation from the norm, progress is not possible. _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm