From patchwork Tue Oct 27 23:10:39 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Oliver Upton X-Patchwork-Id: 11862341 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-20.4 required=3.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4549EC388F9 for ; Wed, 28 Oct 2020 01:49:47 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 037C722258 for ; Wed, 28 Oct 2020 01:49:44 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="DdTWKmn7" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725796AbgJ1BiR (ORCPT ); Tue, 27 Oct 2020 21:38:17 -0400 Received: from mail-pg1-f201.google.com ([209.85.215.201]:39290 "EHLO mail-pg1-f201.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1832969AbgJ0XKy (ORCPT ); Tue, 27 Oct 2020 19:10:54 -0400 Received: by mail-pg1-f201.google.com with SMTP id j10so1559320pgc.6 for ; Tue, 27 Oct 2020 16:10:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=GUpfgn1Atr/2cgV/VF9psyOiQEeFuFoj8Fw//sfCSj8=; b=DdTWKmn7fGFcxd+qoXrvE3LWbuDlW7z0ERl0bxE2SMCPY9oeEYk6H+59ceRSwCdf12 Y7OUHygpvbV6KjGKg6j6udXOaDN1VQ9fbEdxv2sDoJNzKpmKnGj7c/6GsvstslkHA9j2 Y0Y8z0SNGqG3o9i/0Hic4U7E8VtIqkfNNaCazTbOcc27BOS7ytp4KGaVzpQnMPGaftfA a7W+2VCcwgt2MAsO0CqhpeAck6tpBU+U43APTa60qO0Ur7R/F9YdCnpghd+vsrUsBPzs pn0wZbTk4nSJO9wfCRYIxMMyJenJ2MESmLBX35DZFY8Ar05nMAREg4R2ONMxWF2Hnt1E e3Lg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=GUpfgn1Atr/2cgV/VF9psyOiQEeFuFoj8Fw//sfCSj8=; b=rNPuiT+9a/LJNhQSHHlO1oz2sm+Cmnlx3HHNZi/kf+LAwtjMOyRHo6NWWpFhVOO4Kl YQMj8ZRDqpO6tOpkrOYNr1XQoOYRtPGuzJHlzEFqVEIr2kz1XRqZp+igNP5Qhs0p5wPq 60UA2KEIC7taXrqmYpqYtQvtT0fS3IyQ5tFy9foes4JFVA2hvzSnoHbak73oNdv6uFCB 80jKMbCOtCNHmy0+stCfUpf1dTZDcvauzJqbHGMuBfyz0g4K+HpK+h2T3fTN5YwAbTN5 i99Eg60OZwnLqUwnzf7246VF/+FHif1f/96vxdr0tOD0WvTWmqJqs91nwS2kKdrSraSa NPvA== X-Gm-Message-State: AOAM530VdN42X4P0KS2KluErtLQyfL12qr4AAugM5xp9NBNIySinYtK5 iaUTn4DXiZP9STrta3Xx2z5pfHbGMxbFEFuTTUf/L7sXohiH5sUDskZO8IkVbdDqbrfd9h8gUmr Y87kGcUDzDliqU3L3duKMIM07Tzu8rr+z0veoJ26aWhdJRgg1sCq5gqucOw== X-Google-Smtp-Source: ABdhPJyEzTEEvDlJjlDbUn/6XfE1h8nlUGycDTApGRN9bfGl+92UGQWSSM7P9UEOct96Ma7ISmCTPBIjC+U= Sender: "oupton via sendgmr" X-Received: from oupton.sea.corp.google.com ([2620:15c:100:202:f693:9fff:fef5:7be1]) (user=oupton job=sendgmr) by 2002:a17:902:d213:b029:d4:d273:d40a with SMTP id t19-20020a170902d213b02900d4d273d40amr4692991ply.76.1603840253558; Tue, 27 Oct 2020 16:10:53 -0700 (PDT) Date: Tue, 27 Oct 2020 16:10:39 -0700 In-Reply-To: <20201027231044.655110-1-oupton@google.com> Message-Id: <20201027231044.655110-2-oupton@google.com> Mime-Version: 1.0 References: <20201027231044.655110-1-oupton@google.com> X-Mailer: git-send-email 2.29.0.rc2.309.g374f81d7ae-goog Subject: [PATCH 1/6] selftests: kvm: add tsc_msrs_test binary to gitignore From: Oliver Upton To: kvm@vger.kernel.org Cc: Paolo Bonzini , Sean Christopherson , Oliver Upton Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Fixes: 0c899c25d754 ("KVM: x86: do not attempt TSC synchronization on guest writes") Signed-off-by: Oliver Upton --- tools/testing/selftests/kvm/.gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore index 307ceaadbbb9..0f19f5999b88 100644 --- a/tools/testing/selftests/kvm/.gitignore +++ b/tools/testing/selftests/kvm/.gitignore @@ -15,6 +15,7 @@ /x86_64/vmx_preemption_timer_test /x86_64/svm_vmcall_test /x86_64/sync_regs_test +/x86_64/tsc_msrs_test /x86_64/vmx_close_while_nested_test /x86_64/vmx_dirty_log_test /x86_64/vmx_set_nested_state_test From patchwork Tue Oct 27 23:10:40 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Oliver Upton X-Patchwork-Id: 11862337 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-20.4 required=3.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 363ABC55179 for ; Wed, 28 Oct 2020 01:49:33 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id F3B8422258 for ; Wed, 28 Oct 2020 01:49:32 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="e8acWBkg" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725812AbgJ1BiS (ORCPT ); Tue, 27 Oct 2020 21:38:18 -0400 Received: from mail-qv1-f73.google.com ([209.85.219.73]:41123 "EHLO mail-qv1-f73.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1832970AbgJ0XK7 (ORCPT ); Tue, 27 Oct 2020 19:10:59 -0400 Received: by mail-qv1-f73.google.com with SMTP id c6so1857041qvo.8 for ; Tue, 27 Oct 2020 16:10:58 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=zTWeeM0gj4b+EZMzzsOuDy3TtUXgOfnUzZ7xyejxMz4=; b=e8acWBkgA6aNGezOtnocVItGlAOaDmHZl4Jm08GenX+pg8ZGT0T+4/puDL5oNhpLzb XcGU2roUbDv4Nm19ykA2Op3gcHOJvL7VswB0uoy3ncwnYbdqrL826cWz81nimpPbplKn 3AOi0IvtN5E9k91PqCU3y7FyBayUaFnalP7icI6vIamF4bH+1YvX+nUAcSupFIjrtm84 X2W90MEgoT7O7lKZ77ccd3q6DbAsfACpMhrCG4SIKsbncHzHHujIz4RdzujUTsyN9M8h uTtgDsoEdHBo2L2STPDygpkaJSvGpajm149ev9lwTUlR1tzE82sMOo4+2b5BV3sMLBUJ LWVw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=zTWeeM0gj4b+EZMzzsOuDy3TtUXgOfnUzZ7xyejxMz4=; b=qZjtaKCz7tPnG9LpdYrcM8XZ6H+JxYPxo5tomklegYmeF30zxanJ40jcmsg8A5pIjE tDFHAtfYKkcECp7KTQ8D5PhAd7YWosze9fLkKeOcZVeqdLFZ4fhiMWlHgp8173jflqKj 1hpjO949/2PppARxViw3GJYa3GsE4EeHLi3xGwMnOs3CkXCLUOE2B1PDs6L+wmqGM578 LVz7ZgaG1OPYNK7DC4XC4PB0a9bEGQKZhu4fBJjwoVlbF0GzNmi+BdA0Q/qYYyP4fRSq s3y1HLIRulZ46FZUy+v823Z4MV8aLxCjHeYpONstNwwffRsev4xjbhZIjpXwKIjLCCJC RrBw== X-Gm-Message-State: AOAM532DvgE8eCoZl5vFzpdPyrxw5NHhuAfqf7ewUOfcbH/N6E2Vs1g+ vNN+Nhkfb/mSDDAhjCWDHXltxUaoCpuF1DaEL7ZhWSHlwyGx6oq9vR3XIx38F8D5AbHhlpFwJDB dY472/S59IL/tdzfwUbIKb32G7f+jGWaxgkAI0Qe4rG9HfHic6KfBgLY2/Q== X-Google-Smtp-Source: ABdhPJzCoj87WMAPI7uZp6Rn2R2h2ntEUHQdRosJ1+mvRd95aCRbkOb7ixRcSZm/7w2UUZfwMgaob/lrxtA= Sender: "oupton via sendgmr" X-Received: from oupton.sea.corp.google.com ([2620:15c:100:202:f693:9fff:fef5:7be1]) (user=oupton job=sendgmr) by 2002:a05:6214:b84:: with SMTP id fe4mr5126248qvb.3.1603840257726; Tue, 27 Oct 2020 16:10:57 -0700 (PDT) Date: Tue, 27 Oct 2020 16:10:40 -0700 In-Reply-To: <20201027231044.655110-1-oupton@google.com> Message-Id: <20201027231044.655110-3-oupton@google.com> Mime-Version: 1.0 References: <20201027231044.655110-1-oupton@google.com> X-Mailer: git-send-email 2.29.0.rc2.309.g374f81d7ae-goog Subject: [PATCH 2/6] Documentation: kvm: fix ordering of msr filter, pv documentation From: Oliver Upton To: kvm@vger.kernel.org Cc: Paolo Bonzini , Sean Christopherson , Oliver Upton , Aaron Lewis Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Both were added around the same time, so it seems they collide for the next heading number. Fixes: 1a155254ff93 ("KVM: x86: Introduce MSR filtering") Fixes: 66570e966dd9 ("kvm: x86: only provide PV features if enabled in guest's CPUID") Signed-off-by: Oliver Upton Reviewed-by: Aaron Lewis --- Documentation/virt/kvm/api.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Documentation/virt/kvm/api.rst b/Documentation/virt/kvm/api.rst index 76317221d29f..fbc6a5e4585f 100644 --- a/Documentation/virt/kvm/api.rst +++ b/Documentation/virt/kvm/api.rst @@ -6367,7 +6367,7 @@ accesses that would usually trigger a #GP by KVM into the guest will instead get bounced to user space through the KVM_EXIT_X86_RDMSR and KVM_EXIT_X86_WRMSR exit notifications. -8.25 KVM_X86_SET_MSR_FILTER +8.27 KVM_X86_SET_MSR_FILTER --------------------------- :Architectures: x86 @@ -6382,7 +6382,7 @@ trap and emulate MSRs that are outside of the scope of KVM as well as limit the attack surface on KVM's MSR emulation code. -8.26 KVM_CAP_ENFORCE_PV_CPUID +8.28 KVM_CAP_ENFORCE_PV_CPUID ----------------------------- Architectures: x86 From patchwork Tue Oct 27 23:10:41 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Oliver Upton X-Patchwork-Id: 11862339 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-20.4 required=3.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 24DBAC388F9 for ; Wed, 28 Oct 2020 01:49:25 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id DF21E22258 for ; Wed, 28 Oct 2020 01:49:24 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="r/4IraGL" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725829AbgJ1BiS (ORCPT ); Tue, 27 Oct 2020 21:38:18 -0400 Received: from mail-pl1-f202.google.com ([209.85.214.202]:37354 "EHLO mail-pl1-f202.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1832971AbgJ0XLF (ORCPT ); Tue, 27 Oct 2020 19:11:05 -0400 Received: by mail-pl1-f202.google.com with SMTP id 97so1755451plb.4 for ; Tue, 27 Oct 2020 16:11:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=QUFSJ8N3j5rCuH96XCqYU4E4BtH6cunGKFD8JyT6Wpo=; b=r/4IraGLuKexwiV4T8yVpqYQRieLnqGD7NDujIsr5sjIwW/pHJ4g8K9GZgIlxKUErl eQCCeSTpxSMaMTN99G3mhZD+0SQEWD88QV9wMU8BG1ilN6N0dsdhXlZuUe6lNukF/efA CEo0Ow+hxslt3ixHJBW8ZXLaEiPLkrd+FqUV7pqOBVoMT6lfE0i8FQ1fZlpvSMjVgbbX UfoN47N89RmfG1WTQW1NF1lYFK88/f2+SEej6qeSBAdTDqJZgRpi6GT1C3doyfM9kZNu btoiyts3N7bVspkxPpd2I8GoCHonKDhLX5NOmZPMVWiVkZMKp1oMHzePQHDNm+6ySGZU /35Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=QUFSJ8N3j5rCuH96XCqYU4E4BtH6cunGKFD8JyT6Wpo=; b=LqpSBGo2lu9D9hiE4n709s1nPuDpFlmHf0M6BIhYjOGcJEYjffAS6QCz2NLZFkxysI cutaEk+tNbHwL6mXJJKkMbFBoGzII1BfWigBiZMTHZ8tP0NBfwf7V1S3NGya9c6ntvSF hwfHbxuI1glBb2h5tboqXzRUnql4ZEgs3g2r0zROf1pKBR1w0t86lGi1WnX/E60n5ETe 6liurtM6pl06Wbty+QbK1ZXpIa/ZJEQt8Gtb51LOPDId5eFXRyXcSolO1JT0iyVtIVo6 o+PG2LaBIyogydXOllTgoYUVNBkHDTFAItH4tqu9ea3ckK2/g8oiPAAVXYNvzqDFLXPN mkVw== X-Gm-Message-State: AOAM5301Q8/fvaVi8HVnEoZw6Ol0ZepYGcDzHxW3azTtSRIdG6z6INjX BiZw4shjhSXmKyhJLuEdRsG4DUwAToyHwPGxndG6lybBk+6DUu5o+0H18Oyl5cOrR89H7iMAaUD FqMs3GyLsnChIpkUyzKotdZppLLy/Bzz20PWqiPBp5INC8Va2BwbL8+ILgw== X-Google-Smtp-Source: ABdhPJwffLlyv05UedwKlZLHNONqYMiSeTcznfUkw8uc84K1VTBGdcmxkXiCkQ0cUMckYZpeI52ooYLBNEw= Sender: "oupton via sendgmr" X-Received: from oupton.sea.corp.google.com ([2620:15c:100:202:f693:9fff:fef5:7be1]) (user=oupton job=sendgmr) by 2002:a62:6101:0:b029:163:afcb:9b94 with SMTP id v1-20020a6261010000b0290163afcb9b94mr4668165pfb.45.1603840263053; Tue, 27 Oct 2020 16:11:03 -0700 (PDT) Date: Tue, 27 Oct 2020 16:10:41 -0700 In-Reply-To: <20201027231044.655110-1-oupton@google.com> Message-Id: <20201027231044.655110-4-oupton@google.com> Mime-Version: 1.0 References: <20201027231044.655110-1-oupton@google.com> X-Mailer: git-send-email 2.29.0.rc2.309.g374f81d7ae-goog Subject: [PATCH 3/6] kvm: x86: reads of restricted pv msrs should also result in #GP From: Oliver Upton To: kvm@vger.kernel.org Cc: Paolo Bonzini , Sean Christopherson , Oliver Upton , Peter Shier Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org commit 66570e966dd9 ("kvm: x86: only provide PV features if enabled in guest's CPUID") only protects against disallowed guest writes to KVM paravirtual msrs, leaving msr reads unchecked. Fix this by enforcing KVM_CPUID_FEATURES for msr reads as well. Fixes: 66570e966dd9 ("kvm: x86: only provide PV features if enabled in guest's CPUID") Signed-off-by: Oliver Upton Reviewed-by: Peter Shier --- arch/x86/kvm/x86.c | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c index 397f599b20e5..4016c07c8920 100644 --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c @@ -3463,29 +3463,63 @@ int kvm_get_msr_common(struct kvm_vcpu *vcpu, struct msr_data *msr_info) msr_info->data = vcpu->arch.efer; break; case MSR_KVM_WALL_CLOCK: + if (!guest_pv_has(vcpu, KVM_FEATURE_CLOCKSOURCE)) + return 1; + + msr_info->data = vcpu->kvm->arch.wall_clock; + break; case MSR_KVM_WALL_CLOCK_NEW: + if (!guest_pv_has(vcpu, KVM_FEATURE_CLOCKSOURCE2)) + return 1; + msr_info->data = vcpu->kvm->arch.wall_clock; break; case MSR_KVM_SYSTEM_TIME: + if (!guest_pv_has(vcpu, KVM_FEATURE_CLOCKSOURCE)) + return 1; + + msr_info->data = vcpu->arch.time; + break; case MSR_KVM_SYSTEM_TIME_NEW: + if (!guest_pv_has(vcpu, KVM_FEATURE_CLOCKSOURCE2)) + return 1; + msr_info->data = vcpu->arch.time; break; case MSR_KVM_ASYNC_PF_EN: + if (!guest_pv_has(vcpu, KVM_FEATURE_ASYNC_PF)) + return 1; + msr_info->data = vcpu->arch.apf.msr_en_val; break; case MSR_KVM_ASYNC_PF_INT: + if (!guest_pv_has(vcpu, KVM_FEATURE_ASYNC_PF_INT)) + return 1; + msr_info->data = vcpu->arch.apf.msr_int_val; break; case MSR_KVM_ASYNC_PF_ACK: + if (!guest_pv_has(vcpu, KVM_FEATURE_ASYNC_PF)) + return 1; + msr_info->data = 0; break; case MSR_KVM_STEAL_TIME: + if (!guest_pv_has(vcpu, KVM_FEATURE_STEAL_TIME)) + return 1; + msr_info->data = vcpu->arch.st.msr_val; break; case MSR_KVM_PV_EOI_EN: + if (!guest_pv_has(vcpu, KVM_FEATURE_PV_EOI)) + return 1; + msr_info->data = vcpu->arch.pv_eoi.msr_val; break; case MSR_KVM_POLL_CONTROL: + if (!guest_pv_has(vcpu, KVM_FEATURE_POLL_CONTROL)) + return 1; + msr_info->data = vcpu->arch.msr_kvm_poll_control; break; case MSR_IA32_P5_MC_ADDR: From patchwork Tue Oct 27 23:10:42 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Oliver Upton X-Patchwork-Id: 11862285 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-20.4 required=3.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id C20FBC55179 for ; Wed, 28 Oct 2020 01:38:20 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 5C7F822384 for ; Wed, 28 Oct 2020 01:38:20 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="QDOcwvFM" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725841AbgJ1BiT (ORCPT ); Tue, 27 Oct 2020 21:38:19 -0400 Received: from mail-yb1-f202.google.com ([209.85.219.202]:42595 "EHLO mail-yb1-f202.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1832972AbgJ0XLJ (ORCPT ); Tue, 27 Oct 2020 19:11:09 -0400 Received: by mail-yb1-f202.google.com with SMTP id u13so3114030ybk.9 for ; Tue, 27 Oct 2020 16:11:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=Naifs7owNcfj47yxgHsuvjNi7Wp+K1Q0X17CuMJUCEM=; b=QDOcwvFMVzLTVHuE0DRFkyoDUJyELxZngbiCC1qWUugFXcHraJQj6WBNzdsus+EkcC H4/RTFX4HV6iQwDfRkM3qbXUSwPspy7yY6miYlmcGw5XPhV7xRv++Msezbxsl0ocGKlD 2IZ6pkXtDVx5CgtBYhkZef7/q8mKR/SxZ7GxFwCe8claU4hM/CYv+O7lx4vWi/VLeaO0 mnxQgLj6sl2rm3g11wCm9tNfhqy/urZgiMWAn25Ww7TH9hj2xpmHKdt2TttL/XRNULBR xBEfPIdcFm+1wzUIgrc8JD06F7Sio+103663xJAF0PBtBMW5oxFGjHtEH+utd5VPO20+ ySzw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=Naifs7owNcfj47yxgHsuvjNi7Wp+K1Q0X17CuMJUCEM=; b=s6wslj/o2PHsaMLWl0uB8CJk6uSKpw/X7jOMuyA4MxyrH/uEmbHG4mNnkmnQDcmGYr g1eZ6lRbxuve/qJSywr4lomBlJ4izHvv3w/33mpfKGUi7g/hhBw9rkiD/nkygCAgckcY Ap4K1PLDht+BoK77RRI0YIFYQAgcaX0csO6/EZWrR/vUlpFK8cn6XaPtoNU64Ts+Tj8q UlfPmpFZQmdwRYsq/uh6U9sHgutDQ+OHd71VxCmaLIeYIxSI+s+UR1bXC55LI++oyE4x mfdg1XPphCJaa89h6GeolkX3ETwv/2Iv1gJqqNjMqNvCR4fNs52iLhOioTbMNF7y4c7J nNdg== X-Gm-Message-State: AOAM5325rrGlF2F/ooKzDU7rSQwv60ZB9NOmugyTY6Tryg+0dGd9Xahh PHmC4evcJuAoKZh8/i/n0C0E6WfBi4TXTxzTKxmEi4PMpPpyoP5cu+bijdgtukcBz7xoxbVk8Kp BLWEK1bmyLo2PbttqrpKhNVaij9J7Gc3P59w7WRVcZoOxy4prXWaDTd/Yaw== X-Google-Smtp-Source: ABdhPJy9N5eK8EGvGi6gXjq44vGiSqpfpXS8l5TRQj4KnYmTwhOwX/D8rmDdhTx6ClCemTDda2GjGxTXJbU= Sender: "oupton via sendgmr" X-Received: from oupton.sea.corp.google.com ([2620:15c:100:202:f693:9fff:fef5:7be1]) (user=oupton job=sendgmr) by 2002:a25:f210:: with SMTP id i16mr6696758ybe.139.1603840267141; Tue, 27 Oct 2020 16:11:07 -0700 (PDT) Date: Tue, 27 Oct 2020 16:10:42 -0700 In-Reply-To: <20201027231044.655110-1-oupton@google.com> Message-Id: <20201027231044.655110-5-oupton@google.com> Mime-Version: 1.0 References: <20201027231044.655110-1-oupton@google.com> X-Mailer: git-send-email 2.29.0.rc2.309.g374f81d7ae-goog Subject: [PATCH 4/6] kvm: x86: ensure pv_cpuid.features is initialized when enabling cap From: Oliver Upton To: kvm@vger.kernel.org Cc: Paolo Bonzini , Sean Christopherson , Oliver Upton , Peter Shier Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Make the paravirtual cpuid enforcement mechanism idempotent to ioctl() ordering by updating pv_cpuid.features whenever userspace requests the capability. Extract this update out of kvm_update_cpuid_runtime() into a new helper function and move its other call site into kvm_vcpu_after_set_cpuid() where it more likely belongs. Fixes: 66570e966dd9 ("kvm: x86: only provide PV features if enabled in guest's CPUID") Signed-off-by: Oliver Upton Reviewed-by: Peter Shier --- arch/x86/kvm/cpuid.c | 23 ++++++++++++++++------- arch/x86/kvm/cpuid.h | 1 + arch/x86/kvm/x86.c | 2 ++ 3 files changed, 19 insertions(+), 7 deletions(-) diff --git a/arch/x86/kvm/cpuid.c b/arch/x86/kvm/cpuid.c index 06a278b3701d..d50041f570e8 100644 --- a/arch/x86/kvm/cpuid.c +++ b/arch/x86/kvm/cpuid.c @@ -90,6 +90,20 @@ static int kvm_check_cpuid(struct kvm_cpuid_entry2 *entries, int nent) return 0; } +void kvm_update_pv_runtime(struct kvm_vcpu *vcpu) +{ + struct kvm_cpuid_entry2 *best; + + best = kvm_find_cpuid_entry(vcpu, KVM_CPUID_FEATURES, 0); + + /* + * save the feature bitmap to avoid cpuid lookup for every PV + * operation + */ + if (best) + vcpu->arch.pv_cpuid.features = best->eax; +} + void kvm_update_cpuid_runtime(struct kvm_vcpu *vcpu) { struct kvm_cpuid_entry2 *best; @@ -124,13 +138,6 @@ void kvm_update_cpuid_runtime(struct kvm_vcpu *vcpu) (best->eax & (1 << KVM_FEATURE_PV_UNHALT))) best->eax &= ~(1 << KVM_FEATURE_PV_UNHALT); - /* - * save the feature bitmap to avoid cpuid lookup for every PV - * operation - */ - if (best) - vcpu->arch.pv_cpuid.features = best->eax; - if (!kvm_check_has_quirk(vcpu->kvm, KVM_X86_QUIRK_MISC_ENABLE_NO_MWAIT)) { best = kvm_find_cpuid_entry(vcpu, 0x1, 0); if (best) @@ -162,6 +169,8 @@ static void kvm_vcpu_after_set_cpuid(struct kvm_vcpu *vcpu) vcpu->arch.guest_supported_xcr0 = (best->eax | ((u64)best->edx << 32)) & supported_xcr0; + kvm_update_pv_runtime(vcpu); + vcpu->arch.maxphyaddr = cpuid_query_maxphyaddr(vcpu); kvm_mmu_reset_context(vcpu); diff --git a/arch/x86/kvm/cpuid.h b/arch/x86/kvm/cpuid.h index bf8577947ed2..f7a6e8f83783 100644 --- a/arch/x86/kvm/cpuid.h +++ b/arch/x86/kvm/cpuid.h @@ -11,6 +11,7 @@ extern u32 kvm_cpu_caps[NCAPINTS] __read_mostly; void kvm_set_cpu_caps(void); void kvm_update_cpuid_runtime(struct kvm_vcpu *vcpu); +void kvm_update_pv_runtime(struct kvm_vcpu *vcpu); struct kvm_cpuid_entry2 *kvm_find_cpuid_entry(struct kvm_vcpu *vcpu, u32 function, u32 index); int kvm_dev_ioctl_get_cpuid(struct kvm_cpuid2 *cpuid, diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c index 4016c07c8920..2970045a885e 100644 --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c @@ -4609,6 +4609,8 @@ static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu, case KVM_CAP_ENFORCE_PV_FEATURE_CPUID: vcpu->arch.pv_cpuid.enforce = cap->args[0]; + if (vcpu->arch.pv_cpuid.enforce) + kvm_update_pv_runtime(vcpu); return 0; From patchwork Tue Oct 27 23:10:43 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Oliver Upton X-Patchwork-Id: 11862323 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-20.4 required=3.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 437FAC55178 for ; Wed, 28 Oct 2020 01:49:06 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 035AC22202 for ; Wed, 28 Oct 2020 01:49:06 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="uM4jsXZs" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725857AbgJ1BiT (ORCPT ); Tue, 27 Oct 2020 21:38:19 -0400 Received: from mail-qv1-f73.google.com ([209.85.219.73]:53328 "EHLO mail-qv1-f73.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1832973AbgJ0XLN (ORCPT ); Tue, 27 Oct 2020 19:11:13 -0400 Received: by mail-qv1-f73.google.com with SMTP id z9so1857123qvo.20 for ; Tue, 27 Oct 2020 16:11:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=3+6ectJfOiKDR2LfaiKnLMFM89IuvdIsyMu19K7v2oM=; b=uM4jsXZsNl+FtusXOt8LC/fnbcXL8edJ7kArSXR5lEmdtnPf9gY+IH++dxVnxSmILE ElsfqB2vqVcjXpPirqWczohWQKNuwejJwCaavkUYmO7GaSJXZlNsx9frtSfyNyBQafl6 6rQgoO2mC2wdAqMqVlrcMj3U14lA3SfoaFrCR4jWQsB55RSVrLWNGKIZ3y8a427aj1zO BrYiRdIJrvg+H59CbidQ+tk23nXzCuWxv/3wruwPWDVDgOE90kKh6/6iFCjw+r8uEKR1 WlkxPgzTnLhF3qqb0rdWGovjkvB2HdgiAoXhTn237HM4mOeq5Wdx/Qb4EIgpoSr9mQlf +r9A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=3+6ectJfOiKDR2LfaiKnLMFM89IuvdIsyMu19K7v2oM=; b=cWtlXIsAPALetKd2Fm55DTJkzCg8MNTxiHVasAqF80klHLXN9zEZ9DtvBtOBEOMiRI ew4gR1/uVQMdZNk8xvNkk1EJKOiA0A/Z2l1scp9OEcPIDvZwM5Jv+vpt4e16icF9y4N+ Cl9KAyvuWyUGO+A9+/HhObFtfZRYuhEmXmqQMBjxNdWCXPBCfoxNYZFoiIi89fvKBUq1 4pcyshkcfsvPCr31iSaTlTrPcLUOCy8tuGjwQAjNToBCXvWn3fcBywrz87/LjAV3LsVz dZYBtisG3arjNUFJD5OqyyhfupO6UuGsGhkHpa2lNFiQdtHKosKwLNHRA/R9NjKHXULN LCkg== X-Gm-Message-State: AOAM530fEm1vRUYVVbxmUIChDHpy6m4Qi73U3qodeEp1idWMNot2XPGD Tbaf5xctvdSFL4yFtMBN7AzCPKa/ziKwtPMHapSZL/XMLTlruExEoo8UBRGEDTmkCWbRuziQjXu 3FoxYIelBwCpfX5qeF7HQGaYz1Gy78CbnQVc0RUIxi6stE6NQGLUV6+IOWQ== X-Google-Smtp-Source: ABdhPJyc0GXdLwsQDByePLIyx5jcBiX0bXCKgdhO9KQJ4wsr92CjbX4xA3m7fBjLZ59mntrHqjsB4ty1Euo= Sender: "oupton via sendgmr" X-Received: from oupton.sea.corp.google.com ([2620:15c:100:202:f693:9fff:fef5:7be1]) (user=oupton job=sendgmr) by 2002:a0c:9e20:: with SMTP id p32mr4855505qve.44.1603840271080; Tue, 27 Oct 2020 16:11:11 -0700 (PDT) Date: Tue, 27 Oct 2020 16:10:43 -0700 In-Reply-To: <20201027231044.655110-1-oupton@google.com> Message-Id: <20201027231044.655110-6-oupton@google.com> Mime-Version: 1.0 References: <20201027231044.655110-1-oupton@google.com> X-Mailer: git-send-email 2.29.0.rc2.309.g374f81d7ae-goog Subject: [PATCH 5/6] kvm: x86: request masterclock update any time guest uses different msr From: Oliver Upton To: kvm@vger.kernel.org Cc: Paolo Bonzini , Sean Christopherson , Oliver Upton , Peter Shier Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org commit 66570e966dd9 ("kvm: x86: only provide PV features if enabled in guest's CPUID") subtly changed the behavior of guest writes to MSR_KVM_SYSTEM_TIME(_NEW). Restore the previous behavior; update the masterclock any time the guest uses a different msr than before. Fixes: 66570e966dd9 ("kvm: x86: only provide PV features if enabled in guest's CPUID") Signed-off-by: Oliver Upton Reviewed-by: Peter Shier --- arch/x86/kvm/x86.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c index 2970045a885e..4f7dce1b1447 100644 --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c @@ -1965,7 +1965,7 @@ static void kvm_write_system_time(struct kvm_vcpu *vcpu, gpa_t system_time, struct kvm_arch *ka = &vcpu->kvm->arch; if (vcpu->vcpu_id == 0 && !host_initiated) { - if (ka->boot_vcpu_runs_old_kvmclock && old_msr) + if (ka->boot_vcpu_runs_old_kvmclock != old_msr) kvm_make_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu); ka->boot_vcpu_runs_old_kvmclock = old_msr; From patchwork Tue Oct 27 23:10:44 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Oliver Upton X-Patchwork-Id: 11862321 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-20.4 required=3.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 73738C55178 for ; Wed, 28 Oct 2020 01:48:57 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1753F22202 for ; Wed, 28 Oct 2020 01:48:57 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="lyELrqZh" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725871AbgJ1BiT (ORCPT ); Tue, 27 Oct 2020 21:38:19 -0400 Received: from mail-pg1-f201.google.com ([209.85.215.201]:54066 "EHLO mail-pg1-f201.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1832974AbgJ0XLR (ORCPT ); Tue, 27 Oct 2020 19:11:17 -0400 Received: by mail-pg1-f201.google.com with SMTP id r4so1542881pgl.20 for ; Tue, 27 Oct 2020 16:11:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=KOAF+QiKhSZYVZbSN8EPg1nH9XHSy1gCtbOyRwkqkHQ=; b=lyELrqZhmVNIJM5QJ1ZDxswpI4Ksd3gS4kw/Rg3MOzZWCgcKYTGf6mz0tO5AL8kbSJ 2Rq7FUg9HpN0od1pd9otIgOICqOY7kpTTDLOWG+hurB1pCWcDDzW8Dc7p6H1+dRQJg2s sMpRVROeA2prT4KAmfg+GOMPfY+AKO1XHI1lrbauUrCUhSExbq2hfHNomIFHR8qcsH8R opfAIpk0VZ80aP4HL9W+wZBW/q/GEI/9xsDpHPI6Th+ZssKNROCGez6G7eMKudcJyb+I L0O1cMDyhK/+m1VjYN8StFtx+2KiWxlYRB3m9qJG1kyfLiqxgnr0wA9XuzfiZ4+WlXMb J6aw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=KOAF+QiKhSZYVZbSN8EPg1nH9XHSy1gCtbOyRwkqkHQ=; b=Xg9vG3Ugk7MJaojFH9M07Z6YLW2IXStDHVyHLXx3XvBts85nP5DP9kj0MJQfdYJzbj xmUL7trhUdGWmFPW9rT67dWXzyZmG3FF+qBDjIGU+nwpZQZIH6XmBg+JOAnMErGGFJ16 AJ58xxlHQEyGGfVvtTxMv+Er9iT4nUVdiAzwe9P/2F1NZmmy4MpV8//4F8VI58cdNI83 Nr3592ppGhddJYbdUxBoyAzv2iVq0IFGHWKk3G8QxOG7YyuyytW4UKCmyJLNmhPYdojj wtr83v/MXuFSjlN2Jg1HSEQHSDd4d1ExZYWLwQrbCO+zgfQMnJcaQre6pCILBggsQYPs Ru3Q== X-Gm-Message-State: AOAM5339N07/zPLqUkSS7vqK1XjSnbZBJuNQlfwMNYBTinH+KRCvMp3F Bx0bDCBiOwo88hAYqMhIsqkwGSbZjWgvELeXSmL+nJQAyHiRaqb6qMpmFMlCPwPMvaCW/vTPWo2 /yG1wQlKibhmUFMQfDg/qPX+O9g0T7M1WxT0ee0VQ6DXU4QwXNoVwKmRR+A== X-Google-Smtp-Source: ABdhPJwWDSsbGtn+Cec5IUGVwd7M7WxnUC2bXnyCX3npmFkgdTPsLNO4OaHE+JPLWmKwVonStAkTvoG0AtA= Sender: "oupton via sendgmr" X-Received: from oupton.sea.corp.google.com ([2620:15c:100:202:f693:9fff:fef5:7be1]) (user=oupton job=sendgmr) by 2002:a65:6493:: with SMTP id e19mr3726750pgv.276.1603840275388; Tue, 27 Oct 2020 16:11:15 -0700 (PDT) Date: Tue, 27 Oct 2020 16:10:44 -0700 In-Reply-To: <20201027231044.655110-1-oupton@google.com> Message-Id: <20201027231044.655110-7-oupton@google.com> Mime-Version: 1.0 References: <20201027231044.655110-1-oupton@google.com> X-Mailer: git-send-email 2.29.0.rc2.309.g374f81d7ae-goog Subject: [PATCH 6/6] selftests: kvm: test enforcement of paravirtual cpuid features From: Oliver Upton To: kvm@vger.kernel.org Cc: Paolo Bonzini , Sean Christopherson , Oliver Upton , Jim Mattson , Peter Shier , Aaron Lewis Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Add a set of tests that ensure the guest cannot access paravirtual msrs and hypercalls that have been disabled in the KVM_CPUID_FEATURES leaf. Expect a #GP in the case of msr accesses and -KVM_ENOSYS from hypercalls. Cc: Jim Mattson Signed-off-by: Oliver Upton Reviewed-by: Peter Shier Reviewed-by: Aaron Lewis --- tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 1 + .../testing/selftests/kvm/include/kvm_util.h | 2 + .../selftests/kvm/include/x86_64/processor.h | 12 + tools/testing/selftests/kvm/lib/kvm_util.c | 28 +++ .../selftests/kvm/lib/x86_64/processor.c | 29 +++ .../selftests/kvm/x86_64/kvm_pv_test.c | 234 ++++++++++++++++++ 7 files changed, 307 insertions(+) create mode 100644 tools/testing/selftests/kvm/x86_64/kvm_pv_test.c diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore index 0f19f5999b88..a10f58a94ff4 100644 --- a/tools/testing/selftests/kvm/.gitignore +++ b/tools/testing/selftests/kvm/.gitignore @@ -5,6 +5,7 @@ /x86_64/cr4_cpuid_sync_test /x86_64/debug_regs /x86_64/evmcs_test +/x86_64/kvm_pv_test /x86_64/hyperv_cpuid /x86_64/mmio_warning_test /x86_64/platform_info_test diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile index 7ebe71fbca53..23f51e1c21be 100644 --- a/tools/testing/selftests/kvm/Makefile +++ b/tools/testing/selftests/kvm/Makefile @@ -41,6 +41,7 @@ LIBKVM_s390x = lib/s390x/processor.c lib/s390x/ucall.c TEST_GEN_PROGS_x86_64 = x86_64/cr4_cpuid_sync_test TEST_GEN_PROGS_x86_64 += x86_64/evmcs_test TEST_GEN_PROGS_x86_64 += x86_64/hyperv_cpuid +TEST_GEN_PROGS_x86_64 += x86_64/kvm_pv_test TEST_GEN_PROGS_x86_64 += x86_64/mmio_warning_test TEST_GEN_PROGS_x86_64 += x86_64/platform_info_test TEST_GEN_PROGS_x86_64 += x86_64/set_sregs_test diff --git a/tools/testing/selftests/kvm/include/kvm_util.h b/tools/testing/selftests/kvm/include/kvm_util.h index 919e161dd289..a288afefde56 100644 --- a/tools/testing/selftests/kvm/include/kvm_util.h +++ b/tools/testing/selftests/kvm/include/kvm_util.h @@ -63,6 +63,8 @@ enum vm_mem_backing_src_type { int kvm_check_cap(long cap); int vm_enable_cap(struct kvm_vm *vm, struct kvm_enable_cap *cap); +int vcpu_enable_cap(struct kvm_vm *vm, uint32_t vcpu_id, + struct kvm_enable_cap *cap); struct kvm_vm *vm_create(enum vm_guest_mode mode, uint64_t phy_pages, int perm); struct kvm_vm *_vm_create(enum vm_guest_mode mode, uint64_t phy_pages, int perm); diff --git a/tools/testing/selftests/kvm/include/x86_64/processor.h b/tools/testing/selftests/kvm/include/x86_64/processor.h index 82b7fe16a824..936380e1c590 100644 --- a/tools/testing/selftests/kvm/include/x86_64/processor.h +++ b/tools/testing/selftests/kvm/include/x86_64/processor.h @@ -338,6 +338,18 @@ uint32_t kvm_get_cpuid_max_basic(void); uint32_t kvm_get_cpuid_max_extended(void); void kvm_get_cpu_address_width(unsigned int *pa_bits, unsigned int *va_bits); +/* + * set_cpuid() - overwrites a matching cpuid entry with the provided value. + * matches based on ent->function && ent->index. returns true + * if a match was found and successfully overwritten. + * @cpuid: the kvm cpuid list to modify. + * @ent: cpuid entry to insert + */ +bool set_cpuid(struct kvm_cpuid2 *cpuid, struct kvm_cpuid_entry2 *ent); + +uint64_t kvm_hypercall(uint64_t nr, uint64_t a0, uint64_t a1, uint64_t a2, + uint64_t a3); + /* * Basic CPU control in CR0 */ diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c index 74776ee228f2..706b19445acc 100644 --- a/tools/testing/selftests/kvm/lib/kvm_util.c +++ b/tools/testing/selftests/kvm/lib/kvm_util.c @@ -85,6 +85,34 @@ int vm_enable_cap(struct kvm_vm *vm, struct kvm_enable_cap *cap) return ret; } +/* VCPU Enable Capability + * + * Input Args: + * vm - Virtual Machine + * vcpu_id - VCPU + * cap - Capability + * + * Output Args: None + * + * Return: On success, 0. On failure a TEST_ASSERT failure is produced. + * + * Enables a capability (KVM_CAP_*) on the VCPU. + */ +int vcpu_enable_cap(struct kvm_vm *vm, uint32_t vcpu_id, + struct kvm_enable_cap *cap) +{ + struct vcpu *vcpu = vcpu_find(vm, vcpu_id); + int r; + + TEST_ASSERT(vcpu, "cannot find vcpu %d", vcpu_id); + + r = ioctl(vcpu->fd, KVM_ENABLE_CAP, cap); + TEST_ASSERT(!r, "KVM_ENABLE_CAP vCPU ioctl failed,\n" + " rc: %i, errno: %i", r, errno); + + return r; +} + static void vm_open(struct kvm_vm *vm, int perm) { vm->kvm_fd = open(KVM_DEV_PATH, perm); diff --git a/tools/testing/selftests/kvm/lib/x86_64/processor.c b/tools/testing/selftests/kvm/lib/x86_64/processor.c index f6eb34eaa0d2..a20bdc6b1228 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/processor.c +++ b/tools/testing/selftests/kvm/lib/x86_64/processor.c @@ -1118,3 +1118,32 @@ void kvm_get_cpu_address_width(unsigned int *pa_bits, unsigned int *va_bits) *va_bits = (entry->eax >> 8) & 0xff; } } + +bool set_cpuid(struct kvm_cpuid2 *cpuid, + struct kvm_cpuid_entry2 *ent) +{ + int i; + + for (i = 0; i < cpuid->nent; i++) { + struct kvm_cpuid_entry2 *cur = &cpuid->entries[i]; + + if (cur->function != ent->function || cur->index != ent->index) + continue; + + memcpy(cur, ent, sizeof(struct kvm_cpuid_entry2)); + return true; + } + + return false; +} + +uint64_t kvm_hypercall(uint64_t nr, uint64_t a0, uint64_t a1, uint64_t a2, + uint64_t a3) +{ + uint64_t r; + + asm volatile("vmcall" + : "=a"(r) + : "b"(a0), "c"(a1), "d"(a2), "S"(a3)); + return r; +} diff --git a/tools/testing/selftests/kvm/x86_64/kvm_pv_test.c b/tools/testing/selftests/kvm/x86_64/kvm_pv_test.c new file mode 100644 index 000000000000..b10a27485bad --- /dev/null +++ b/tools/testing/selftests/kvm/x86_64/kvm_pv_test.c @@ -0,0 +1,234 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2020, Google LLC. + * + * Tests for KVM paravirtual feature disablement + */ +#include +#include +#include + +#include "test_util.h" +#include "kvm_util.h" +#include "processor.h" + +extern unsigned char rdmsr_start; +extern unsigned char rdmsr_end; + +static u64 do_rdmsr(u32 idx) +{ + u32 lo, hi; + + asm volatile("rdmsr_start: rdmsr;" + "rdmsr_end:" + : "=a"(lo), "=c"(hi) + : "c"(idx)); + + return (((u64) hi) << 32) | lo; +} + +extern unsigned char wrmsr_start; +extern unsigned char wrmsr_end; + +static void do_wrmsr(u32 idx, u64 val) +{ + u32 lo, hi; + + lo = val; + hi = val >> 32; + + asm volatile("wrmsr_start: wrmsr;" + "wrmsr_end:" + : : "a"(lo), "c"(idx), "d"(hi)); +} + +static int nr_gp; + +static void guest_gp_handler(struct ex_regs *regs) +{ + unsigned char *rip = (unsigned char *)regs->rip; + bool r, w; + + r = rip == &rdmsr_start; + w = rip == &wrmsr_start; + GUEST_ASSERT(r || w); + + nr_gp++; + + if (r) + regs->rip = (uint64_t)&rdmsr_end; + else + regs->rip = (uint64_t)&wrmsr_end; +} + +struct msr_data { + uint32_t idx; + const char *name; +}; + +#define TEST_MSR(msr) { .idx = msr, .name = #msr } +#define UCALL_PR_MSR 0xdeadbeef +#define PR_MSR(msr) ucall(UCALL_PR_MSR, 1, msr) + +/* + * KVM paravirtual msrs to test. Expect a #GP if any of these msrs are read or + * written, as the KVM_CPUID_FEATURES leaf is cleared. + */ +static struct msr_data msrs_to_test[] = { + TEST_MSR(MSR_KVM_SYSTEM_TIME), + TEST_MSR(MSR_KVM_SYSTEM_TIME_NEW), + TEST_MSR(MSR_KVM_WALL_CLOCK), + TEST_MSR(MSR_KVM_WALL_CLOCK_NEW), + TEST_MSR(MSR_KVM_ASYNC_PF_EN), + TEST_MSR(MSR_KVM_STEAL_TIME), + TEST_MSR(MSR_KVM_PV_EOI_EN), + TEST_MSR(MSR_KVM_POLL_CONTROL), + TEST_MSR(MSR_KVM_ASYNC_PF_INT), + TEST_MSR(MSR_KVM_ASYNC_PF_ACK), +}; + +static void test_msr(struct msr_data *msr) +{ + PR_MSR(msr); + do_rdmsr(msr->idx); + GUEST_ASSERT(READ_ONCE(nr_gp) == 1); + + nr_gp = 0; + do_wrmsr(msr->idx, 0); + GUEST_ASSERT(READ_ONCE(nr_gp) == 1); + nr_gp = 0; +} + +struct hcall_data { + uint64_t nr; + const char *name; +}; + +#define TEST_HCALL(hc) { .nr = hc, .name = #hc } +#define UCALL_PR_HCALL 0xdeadc0de +#define PR_HCALL(hc) ucall(UCALL_PR_HCALL, 1, hc) + +/* + * KVM hypercalls to test. Expect -KVM_ENOSYS when called, as the corresponding + * features have been cleared in KVM_CPUID_FEATURES. + */ +static struct hcall_data hcalls_to_test[] = { + TEST_HCALL(KVM_HC_KICK_CPU), + TEST_HCALL(KVM_HC_SEND_IPI), + TEST_HCALL(KVM_HC_SCHED_YIELD), +}; + +static void test_hcall(struct hcall_data *hc) +{ + uint64_t r; + + PR_HCALL(hc); + r = kvm_hypercall(hc->nr, 0, 0, 0, 0); + GUEST_ASSERT(r == -KVM_ENOSYS); +} + +static void guest_main(void) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(msrs_to_test); i++) { + test_msr(&msrs_to_test[i]); + } + + for (i = 0; i < ARRAY_SIZE(hcalls_to_test); i++) { + test_hcall(&hcalls_to_test[i]); + } + + GUEST_DONE(); +} + +static void clear_kvm_cpuid_features(struct kvm_cpuid2 *cpuid) +{ + struct kvm_cpuid_entry2 ent = {0}; + + ent.function = KVM_CPUID_FEATURES; + TEST_ASSERT(set_cpuid(cpuid, &ent), + "failed to clear KVM_CPUID_FEATURES leaf"); +} + +static void pr_msr(struct ucall *uc) +{ + struct msr_data *msr = (struct msr_data *)uc->args[0]; + + pr_info("testing msr: %s (%#x)\n", msr->name, msr->idx); +} + +static void pr_hcall(struct ucall *uc) +{ + struct hcall_data *hc = (struct hcall_data *)uc->args[0]; + + pr_info("testing hcall: %s (%lu)\n", hc->name, hc->nr); +} + +static void handle_abort(struct ucall *uc) +{ + TEST_FAIL("%s at %s:%ld", (const char *)uc->args[0], + __FILE__, uc->args[1]); +} + +#define VCPU_ID 0 + +static void enter_guest(struct kvm_vm *vm) +{ + struct kvm_run *run; + struct ucall uc; + int r; + + run = vcpu_state(vm, VCPU_ID); + + while (true) { + r = _vcpu_run(vm, VCPU_ID); + TEST_ASSERT(!r, "vcpu_run failed: %d\n", r); + TEST_ASSERT(run->exit_reason == KVM_EXIT_IO, + "unexpected exit reason: %u (%s)", + run->exit_reason, exit_reason_str(run->exit_reason)); + + switch (get_ucall(vm, VCPU_ID, &uc)) { + case UCALL_PR_MSR: + pr_msr(&uc); + break; + case UCALL_PR_HCALL: + pr_hcall(&uc); + break; + case UCALL_ABORT: + handle_abort(&uc); + return; + case UCALL_DONE: + return; + } + } +} + +int main(void) +{ + struct kvm_enable_cap cap = {0}; + struct kvm_cpuid2 *best; + struct kvm_vm *vm; + + if (!kvm_check_cap(KVM_CAP_ENFORCE_PV_FEATURE_CPUID)) { + pr_info("will skip kvm paravirt restriction tests.\n"); + return 0; + } + + vm = vm_create_default(VCPU_ID, 0, guest_main); + + cap.cap = KVM_CAP_ENFORCE_PV_FEATURE_CPUID; + cap.args[0] = 1; + vcpu_enable_cap(vm, VCPU_ID, &cap); + + best = kvm_get_supported_cpuid(); + clear_kvm_cpuid_features(best); + vcpu_set_cpuid(vm, VCPU_ID, best); + + vm_init_descriptor_tables(vm); + vcpu_init_descriptor_tables(vm, VCPU_ID); + vm_handle_exception(vm, GP_VECTOR, guest_gp_handler); + + enter_guest(vm); + kvm_vm_free(vm); +}