From patchwork Fri Dec 23 00:13:45 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Vishal Annapurve X-Patchwork-Id: 36019 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:adf:e747:0:0:0:0:0 with SMTP id c7csp55447wrn; Thu, 22 Dec 2022 16:14:26 -0800 (PST) X-Google-Smtp-Source: AMrXdXvoKbgD8w+bMd0Bf5tHFxdP8y9/21YTIzaFu8CXq10DJqfPu1wT1zrIpsjvyd94Lm+8QBgr X-Received: by 2002:a05:6a20:b23:b0:a3:c099:3a7a with SMTP id x35-20020a056a200b2300b000a3c0993a7amr8414604pzf.22.1671754466665; Thu, 22 Dec 2022 16:14:26 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1671754466; cv=none; d=google.com; s=arc-20160816; b=FFFyGyMvQsnKtfhfNgRo18Kp88z5PF22WqYyl4buiIkUQmAOKeMeumqgYLgpcYJ3CM aJpfi44bS0w6n4/MZP80m0GgPPEZNtpI2hDzXjNIIabXc2QyQfg0gASNfeK+tbuqhaff 6DLvnwhEyq6QfLRafpYdCrJ6nfMAPS76Hhpd1BkWCbGWvtuWhyXxt7aXLXalj5AKVZiJ 8WnmKNlXL/KFzTmAZ3oZChAHSPrFOaCqH3a3dcfent7H3PagiCemALeHsF+LfBKCVOHz RPoLjBjrWYdMoDlVWI1K/O6f4GNgvrZFbvNoMOFilw1zu17g71UtNFseI8hCBLaxHgyo F5PQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:dkim-signature; bh=3CXtB6MmWgwzdyhdYI6wgxsbgDPgAgTn0fSY+N59/F8=; b=iAvWvNlzv1if/1u2PKoLvg3+1M2cHJIeaCcZhgoFkOoYZqrJP2QJ2cCD3RVAhJtVcN Y7oqX+ZhLvNb7qtmxg13IfNRRwYc/jS/bAa9DmPZsurzyHnVLjhGEJ0pnBfnMHPQaqyJ +YQtv/j6UwNHo2J3cpP/Z8CTicj925Ov7FAItNWo0eqKlH7hgr3NSuE3cOLFz62MTnZT +DLezwoLOhDH8aFGv2/fu9kQ7NElfj4eOeF5w68r2EjECw3gDRnUuSwt2bePLqblrCcE Xr8Dsdrf9yy3zId7L1McInXSff4FGdLIusxEgdSMVQ8b1ik5wrgHND8nn9MQvLXeuiob 196w== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=drpNHVsx; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id j13-20020a63ec0d000000b0048e225a6e16si2032156pgh.199.2022.12.22.16.14.13; Thu, 22 Dec 2022 16:14:26 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=drpNHVsx; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230071AbiLWAOD (ORCPT + 99 others); Thu, 22 Dec 2022 19:14:03 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44498 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230028AbiLWAN7 (ORCPT ); Thu, 22 Dec 2022 19:13:59 -0500 Received: from mail-pf1-x44a.google.com (mail-pf1-x44a.google.com [IPv6:2607:f8b0:4864:20::44a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 77FED26543 for ; Thu, 22 Dec 2022 16:13:58 -0800 (PST) Received: by mail-pf1-x44a.google.com with SMTP id e6-20020aa78c46000000b005772151d489so1786803pfd.15 for ; Thu, 22 Dec 2022 16:13:58 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=3CXtB6MmWgwzdyhdYI6wgxsbgDPgAgTn0fSY+N59/F8=; b=drpNHVsxlEQPFFOKpXIeD+HdXUVwglQVf5P3SjgrGRWkac+ExKksqwf2uJcdq6tNAY dzE7DEuw9lOfVmG4IPSHg9ge2WxIe4c3sdbOoBHOuRakO+snBcaTDAt0Ex/WGTRsTYrg b5/8VhWaubp4zJlxmRXrbSSUC/MfGw3nZVk63VY7yoLpxgLU80KPH4J/51ITcwYHISkT Swk4EqO7j+tz4b98gJSbEof3ugrIy8hT5k/XbiZx9Q3rbrQs9Fmj+j09Njf0tHrQX6pX xl2cickkH5OxZPemDApPAiesiswRMUt/uQVQeLGXWKtqOABdpBLcolSi9Qf3ao4VZmEm XyRw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=3CXtB6MmWgwzdyhdYI6wgxsbgDPgAgTn0fSY+N59/F8=; b=JTTWEkMYgxTvuTglGXIvSWNh4K+cYxPbP33hwB5WGwEuG0nWJ07cQoGmFjXu1iTYT8 Yh7vmLNhKql+WzGFv9QC27CAJO/4IwJEy9soax1D0fLTyRUc5B9PX8tj+Yp3y88b064I RUd1dvyBVmLWIIeWnB+7KGfPMjz5L5dygrKS2Y0N1hMKF7+Rcj0YJyZYJM5CyPSQNJvn Wy/Y5EPeBuYHrGdBKr0BFTu2iR382kCuzJ2YeKhPwnNtRoOzut7UvFdaCyy+Rkf+X0Kt eqdepf7cFI0xa2o2SYRS+eJd9hiC+GzF1VkaujxYQMHXHIPeOPceabOuxCeIYf94OTOA zk0Q== X-Gm-Message-State: AFqh2kpJa7r7Da8ISeZERH0QevQovMxGrlAz/9Yu3sADJw09/mRtI7ni 497B3BtDF7rajsICrDuP9FrQAYTyInXMqSmN X-Received: from vannapurve2.c.googlers.com ([fda3:e722:ac3:cc00:7f:e700:c0a8:41f8]) (user=vannapurve job=sendgmr) by 2002:a05:6a00:349b:b0:576:91fa:8ed0 with SMTP id cp27-20020a056a00349b00b0057691fa8ed0mr603715pfb.15.1671754437896; Thu, 22 Dec 2022 16:13:57 -0800 (PST) Date: Fri, 23 Dec 2022 00:13:45 +0000 In-Reply-To: <20221223001352.3873203-1-vannapurve@google.com> Mime-Version: 1.0 References: <20221223001352.3873203-1-vannapurve@google.com> X-Mailer: git-send-email 2.39.0.314.g84b9a713c41-goog Message-ID: <20221223001352.3873203-2-vannapurve@google.com> Subject: [V3 PATCH 1/8] KVM: selftests: private_mem: Use native hypercall From: Vishal Annapurve To: x86@kernel.org, kvm@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org Cc: pbonzini@redhat.com, vkuznets@redhat.com, wanpengli@tencent.com, jmattson@google.com, joro@8bytes.org, tglx@linutronix.de, mingo@redhat.com, bp@alien8.de, dave.hansen@linux.intel.com, hpa@zytor.com, shuah@kernel.org, yang.zhong@intel.com, drjones@redhat.com, ricarkol@google.com, aaronlewis@google.com, wei.w.wang@intel.com, kirill.shutemov@linux.intel.com, corbet@lwn.net, hughd@google.com, jlayton@kernel.org, bfields@fieldses.org, akpm@linux-foundation.org, chao.p.peng@linux.intel.com, yu.c.zhang@linux.intel.com, jun.nakajima@intel.com, dave.hansen@intel.com, michael.roth@amd.com, qperret@google.com, steven.price@arm.com, ak@linux.intel.com, david@redhat.com, luto@kernel.org, vbabka@suse.cz, marcorr@google.com, erdemaktas@google.com, pgonda@google.com, nikunj@amd.com, seanjc@google.com, diviness@google.com, maz@kernel.org, dmatlack@google.com, axelrasmussen@google.com, maciej.szmigiero@oracle.com, mizhang@google.com, bgardon@google.com, ackerleytng@google.com, Vishal Annapurve X-Spam-Status: No, score=-9.6 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_NONE, SPF_HELO_NONE,SPF_PASS,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1752961611644440415?= X-GMAIL-MSGID: =?utf-8?q?1752961611644440415?= CVMs need to execute hypercalls as per the cpu type without relying on KVM emulation. Execute hypercall from the guest using native instructions. Signed-off-by: Vishal Annapurve --- tools/testing/selftests/kvm/lib/x86_64/private_mem.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/kvm/lib/x86_64/private_mem.c b/tools/testing/selftests/kvm/lib/x86_64/private_mem.c index 2b97fc34ec4a..5a8fd8c3bc04 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/private_mem.c +++ b/tools/testing/selftests/kvm/lib/x86_64/private_mem.c @@ -24,7 +24,7 @@ static inline uint64_t __kvm_hypercall_map_gpa_range(uint64_t gpa, uint64_t size, uint64_t flags) { - return kvm_hypercall(KVM_HC_MAP_GPA_RANGE, gpa, size >> PAGE_SHIFT, flags, 0); + return kvm_native_hypercall(KVM_HC_MAP_GPA_RANGE, gpa, size >> PAGE_SHIFT, flags, 0); } static inline void kvm_hypercall_map_gpa_range(uint64_t gpa, uint64_t size, From patchwork Fri Dec 23 00:13:46 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Vishal Annapurve X-Patchwork-Id: 36020 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:adf:e747:0:0:0:0:0 with SMTP id c7csp55659wrn; Thu, 22 Dec 2022 16:14:54 -0800 (PST) X-Google-Smtp-Source: AMrXdXu6gS8LXotpvyVIW9Mhf7/TiBVMc+KQxO6rmU2Me3td2NoIusgtRx35kKRh2fuGSjeuqTMf X-Received: by 2002:a17:902:82c9:b0:192:4ce1:3692 with SMTP id u9-20020a17090282c900b001924ce13692mr6446025plz.53.1671754494326; Thu, 22 Dec 2022 16:14:54 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1671754494; cv=none; d=google.com; s=arc-20160816; b=zxLRF97S5oiYZcJBd7lNuXM51gmJrXUOuaQl2ZI77z2dCsJSm3MBZ54BLKaLWNVS9E CKPcnQZpjCGnfn1uDsfhTFh5l9P65/8vRhD7ad5bWd2bySroePpHLtydXxW5xDb+aXrY RxZhzYuBxB3qbxQREcwHuGC4rKerq0Qncn5QzsZr+tY2i4b7hh+c9+jxtR2nxS5xnA4m zJ8A69BWtBDDetqJE9ku7WppiJd+bPlPHdH/XMvKDXqkQFfwF1NlRNYK/14Fvf6KU5Id 3qj/BTe1UwWWSYu5mug8TWVv+CkeTwCn++7/qnFVWTc10zC2LfWEfRfoVQmquBWoxD0Q jJTg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:dkim-signature; bh=MVS2VPJHypvfItXM6YMyTQGTBGIjipmMwSiUjoXdL8g=; b=c/R45IX5lyqXBTwNkiLDE9HWDXNs0LDiWu3SDC8UYgNVQ/8n6V+/7ihjNuYWQxRyvl sb8LsGWkuPRkNLe8demodoLr2vfCAvPt9nJjmAKzPbjgdPRBlmEsYnGpXIihJIMuhlgf CRMqo84r4zsN1uQIcOM6UlWHTIytsrp6hPwryba0CJsPQnGnGUd5ZbVLhevu8UX6aYc9 c9gCK+SQbrU/QL0bU7aMoaOQD4tTxDmAzbEWcARAS403XScbHtuzPAZIO9fMVy/IcfXP l5HsHLqVOlAmX7WYTne0bYrBJLTf+GIbKxx7gnas7fLuEZbngD1KeGy9JaYkhbWO7Scm 370A== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=XuSDGnZj; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id x23-20020a170902b41700b001781e393237si1709586plr.443.2022.12.22.16.14.40; Thu, 22 Dec 2022 16:14:54 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=XuSDGnZj; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235604AbiLWAOK (ORCPT + 99 others); Thu, 22 Dec 2022 19:14:10 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44540 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230148AbiLWAOB (ORCPT ); Thu, 22 Dec 2022 19:14:01 -0500 Received: from mail-pf1-x44a.google.com (mail-pf1-x44a.google.com [IPv6:2607:f8b0:4864:20::44a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 80F6426AA5 for ; Thu, 22 Dec 2022 16:14:00 -0800 (PST) Received: by mail-pf1-x44a.google.com with SMTP id j1-20020aa78001000000b0057d28e11cb6so1789828pfi.11 for ; Thu, 22 Dec 2022 16:14:00 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=MVS2VPJHypvfItXM6YMyTQGTBGIjipmMwSiUjoXdL8g=; b=XuSDGnZjihxZ6byyIHRt4Ar3HsgSljKfwzl1KDlDhO4Qj64Q5E66DxA2dvI0tLoMTD pk7ozE17dGCcj+MvJCTSiKNdwlEl6jF52KnUALW3lawPPKi+oJUXngTpy8CUcRnbfrET xZkS/kN1R+BsqdqSnrLfKuXSGRKDCF4RAj2hna0jgRDnOyG9iM6OrPHVFHDOcy0Uqwn0 QwME64otg8DEpyacK9CMhahAKHVlUDBetoysoqOXfPZGi/Cpl9f/KtnGjCmpXFhyyPvd jX+4S6miiz4cxFDxnryStGqJ6ZuxUfUTAlJ/bfeqbtnr7POPsZ7aDBSsQ0HxT+8dAA8N tCBA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=MVS2VPJHypvfItXM6YMyTQGTBGIjipmMwSiUjoXdL8g=; b=xKTumXZZj0Mked91a2yCMJ7qAXbX32elHy2V6Cx6T5zziif9qBk515IQs12EOaOTzH HU43W1X1M8jHMr/wNKZnCPFebaS8MqcWWgSUMrY2rBNRwXkzPwe7TxnplWeMlnYMXeD5 euTHSUxPnHOINfWiP96DZdlK9pHfHdbFddZArftxX86ku1zbFVayCcMQitQbgbpazRXm HacYrQjT19HUWKWV0Eb5/EvLbr41TpR/kRSaiolijYKp46/8eRJhYGmvKGQsS0C5mAuW GUZg+9+Dp8kpx3nZZ77uEfstY5DkkpPGnpm7KKft/LBeZo4aWTuLCn31D7NjhsDbpsnR byEA== X-Gm-Message-State: AFqh2kpdlynKrg+pr8nlCZs4AjRm3OvQX3R39KEPegti2CvqIcj9GtSv 7P+6fgysEAwUTpgFC2yQTPCWb2MoMoW5JDmV X-Received: from vannapurve2.c.googlers.com ([fda3:e722:ac3:cc00:7f:e700:c0a8:41f8]) (user=vannapurve job=sendgmr) by 2002:a17:90b:1955:b0:219:b576:d0bd with SMTP id nk21-20020a17090b195500b00219b576d0bdmr682184pjb.123.1671754439977; Thu, 22 Dec 2022 16:13:59 -0800 (PST) Date: Fri, 23 Dec 2022 00:13:46 +0000 In-Reply-To: <20221223001352.3873203-1-vannapurve@google.com> Mime-Version: 1.0 References: <20221223001352.3873203-1-vannapurve@google.com> X-Mailer: git-send-email 2.39.0.314.g84b9a713c41-goog Message-ID: <20221223001352.3873203-3-vannapurve@google.com> Subject: [V3 PATCH 2/8] KVM: selftests: Support mapping pagetables to guest virtual memory From: Vishal Annapurve To: x86@kernel.org, kvm@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org Cc: pbonzini@redhat.com, vkuznets@redhat.com, wanpengli@tencent.com, jmattson@google.com, joro@8bytes.org, tglx@linutronix.de, mingo@redhat.com, bp@alien8.de, dave.hansen@linux.intel.com, hpa@zytor.com, shuah@kernel.org, yang.zhong@intel.com, drjones@redhat.com, ricarkol@google.com, aaronlewis@google.com, wei.w.wang@intel.com, kirill.shutemov@linux.intel.com, corbet@lwn.net, hughd@google.com, jlayton@kernel.org, bfields@fieldses.org, akpm@linux-foundation.org, chao.p.peng@linux.intel.com, yu.c.zhang@linux.intel.com, jun.nakajima@intel.com, dave.hansen@intel.com, michael.roth@amd.com, qperret@google.com, steven.price@arm.com, ak@linux.intel.com, david@redhat.com, luto@kernel.org, vbabka@suse.cz, marcorr@google.com, erdemaktas@google.com, pgonda@google.com, nikunj@amd.com, seanjc@google.com, diviness@google.com, maz@kernel.org, dmatlack@google.com, axelrasmussen@google.com, maciej.szmigiero@oracle.com, mizhang@google.com, bgardon@google.com, ackerleytng@google.com, Vishal Annapurve X-Spam-Status: No, score=-9.6 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_NONE, SPF_HELO_NONE,SPF_PASS,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1752961640586702704?= X-GMAIL-MSGID: =?utf-8?q?1752961640586702704?= Add support for mapping guest pagetables to guest VM regions to allow guests to modify the page table entries at runtime. Add following APIs: 1) vm_set_pgt_alloc_tracking: Track allocations for guest page tables so that such pages can be mapped back to guests later. 2) vm_map_page_table: Map page table pages to guests and pass the information about page table physical pages to virtual address mappings to guests. This framework is useful for the guests whose pagetables can't be manipulated from userspace e.g. confidential VM selftests. Confidential VMs need to change the memory access type by modifying gpa values in their page table entries. Signed-off-by: Vishal Annapurve --- .../selftests/kvm/include/kvm_util_base.h | 88 +++++++++++++++++++ tools/testing/selftests/kvm/lib/kvm_util.c | 88 ++++++++++++++++++- .../selftests/kvm/lib/x86_64/processor.c | 41 +++++++++ 3 files changed, 216 insertions(+), 1 deletion(-) diff --git a/tools/testing/selftests/kvm/include/kvm_util_base.h b/tools/testing/selftests/kvm/include/kvm_util_base.h index a736d6d18fa5..6c286686ec7c 100644 --- a/tools/testing/selftests/kvm/include/kvm_util_base.h +++ b/tools/testing/selftests/kvm/include/kvm_util_base.h @@ -78,6 +78,11 @@ struct protected_vm { int8_t protected_bit; }; +struct pgt_page { + vm_paddr_t paddr; + struct list_head list; +}; + struct kvm_vm { int mode; unsigned long type; @@ -108,6 +113,10 @@ struct kvm_vm { /* VM protection enabled: SEV, etc*/ bool protected; + struct list_head pgt_pages; + bool track_pgt_pages; + uint32_t num_pgt_pages; + vm_vaddr_t pgt_vaddr_start; /* Cache of information for binary stats interface */ int stats_fd; @@ -196,6 +205,25 @@ struct vm_guest_mode_params { unsigned int page_size; unsigned int page_shift; }; + +/* + * Structure shared with the guest containing information about: + * - Starting virtual address for num_pgt_pages physical pagetable + * page addresses tracked via paddrs array + * - page size of the guest + * + * Guest can walk through its pagetables using this information to + * read/modify pagetable attributes. + */ +struct guest_pgt_info { + uint64_t num_pgt_pages; + uint64_t pgt_vaddr_start; + uint64_t page_size; + uint64_t enc_mask; + uint64_t shared_mask; + uint64_t paddrs[]; +}; + extern const struct vm_guest_mode_params vm_guest_mode_params[]; int open_path_or_exit(const char *path, int flags); @@ -411,6 +439,48 @@ void vm_mem_region_delete(struct kvm_vm *vm, uint32_t slot); struct kvm_vcpu *__vm_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id); vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min); vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min); + +/* + * function called by guest code to translate physical address of a pagetable + * page to guest virtual address. + * + * input args: + * gpgt_info - pointer to the guest_pgt_info structure containing info + * about guest virtual address mappings for guest physical + * addresses of page table pages. + * pgt_pa - physical address of guest page table page to be translated + * to a virtual address. + * + * output args: none + * + * return: + * pointer to the pagetable page, null in case physical address is not + * tracked via given guest_pgt_info structure. + */ +void *guest_code_get_pgt_vaddr(struct guest_pgt_info *gpgt_info, uint64_t pgt_pa); + +/* + * 1) Map page table physical pages to the guest virtual address range + * 2) Allocate and setup a page to be shared with guest containing guest_pgt_info + * structure. + * + * Note: + * 1) vm_set_pgt_alloc_tracking function should be used to start tracking + * of physical page table page allocation. + * 2) This function should be invoked after needed pagetable pages are + * mapped to the VM using virt_pg_map. + * + * input args: + * vm - virtual machine + * vaddr_min - Minimum guest virtual address to start mapping the + * guest pagetable pages and guest_pgt_info structure page(s). + * + * output args: none + * + * return: none + */ +void vm_map_page_table(struct kvm_vm *vm, vm_vaddr_t vaddr_min); + vm_vaddr_t vm_vaddr_alloc_shared(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min); vm_vaddr_t vm_vaddr_alloc_pages(struct kvm_vm *vm, int nr_pages); vm_vaddr_t vm_vaddr_alloc_page(struct kvm_vm *vm); @@ -673,10 +743,28 @@ void kvm_gsi_routing_write(struct kvm_vm *vm, struct kvm_irq_routing *routing); const char *exit_reason_str(unsigned int exit_reason); +void sync_vm_gpgt_info(struct kvm_vm *vm, vm_vaddr_t pgt_info); + vm_paddr_t vm_phy_page_alloc(struct kvm_vm *vm, vm_paddr_t paddr_min, uint32_t memslot); vm_paddr_t _vm_phy_pages_alloc(struct kvm_vm *vm, size_t num, vm_paddr_t paddr_min, uint32_t memslot, bool protected); + +/* + * Enable tracking of physical guest pagetable pages for the given vm. + * This function should be called right after vm creation before any pages are + * mapped into the VM using vm_alloc_* / vm_vaddr_alloc* functions. + * + * input args: + * vm - virtual machine + * + * output args: none + * + * return: + * None + */ +void vm_set_pgt_alloc_tracking(struct kvm_vm *vm); + vm_paddr_t vm_alloc_page_table(struct kvm_vm *vm); static inline vm_paddr_t vm_phy_pages_alloc(struct kvm_vm *vm, size_t num, diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c index 37f342a17350..b56be997216a 100644 --- a/tools/testing/selftests/kvm/lib/kvm_util.c +++ b/tools/testing/selftests/kvm/lib/kvm_util.c @@ -202,6 +202,7 @@ struct kvm_vm *____vm_create(enum vm_guest_mode mode, uint64_t nr_pages) TEST_ASSERT(vm != NULL, "Insufficient Memory"); INIT_LIST_HEAD(&vm->vcpus); + INIT_LIST_HEAD(&vm->pgt_pages); vm->regions.gpa_tree = RB_ROOT; vm->regions.hva_tree = RB_ROOT; hash_init(vm->regions.slot_hash); @@ -695,6 +696,7 @@ void kvm_vm_free(struct kvm_vm *vmp) { int ctr; struct hlist_node *node; + struct pgt_page *entry, *nentry; struct userspace_mem_region *region; if (vmp == NULL) @@ -710,6 +712,9 @@ void kvm_vm_free(struct kvm_vm *vmp) hash_for_each_safe(vmp->regions.slot_hash, ctr, node, region, slot_node) __vm_mem_region_delete(vmp, region, false); + list_for_each_entry_safe(entry, nentry, &vmp->pgt_pages, list) + free(entry); + /* Free sparsebit arrays. */ sparsebit_free(&vmp->vpages_valid); sparsebit_free(&vmp->vpages_mapped); @@ -1330,6 +1335,72 @@ vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz, return pgidx_start * vm->page_size; } +void __weak sync_vm_gpgt_info(struct kvm_vm *vm, vm_vaddr_t pgt_info) +{ +} + +void *guest_code_get_pgt_vaddr(struct guest_pgt_info *gpgt_info, + uint64_t pgt_pa) +{ + uint64_t num_pgt_pages = gpgt_info->num_pgt_pages; + uint64_t pgt_vaddr_start = gpgt_info->pgt_vaddr_start; + uint64_t page_size = gpgt_info->page_size; + + for (uint32_t i = 0; i < num_pgt_pages; i++) { + if (gpgt_info->paddrs[i] == pgt_pa) + return (void *)(pgt_vaddr_start + i * page_size); + } + return NULL; +} + +static void vm_setup_pgt_info_buf(struct kvm_vm *vm, vm_vaddr_t vaddr_min) +{ + struct pgt_page *pgt_page_entry; + struct guest_pgt_info *gpgt_info; + uint64_t info_size = sizeof(*gpgt_info) + (sizeof(uint64_t) * vm->num_pgt_pages); + uint64_t num_pages = align_up(info_size, vm->page_size); + vm_vaddr_t buf_start = vm_vaddr_alloc(vm, num_pages, vaddr_min); + uint32_t i = 0; + + gpgt_info = (struct guest_pgt_info *)addr_gva2hva(vm, buf_start); + gpgt_info->num_pgt_pages = vm->num_pgt_pages; + gpgt_info->pgt_vaddr_start = vm->pgt_vaddr_start; + gpgt_info->page_size = vm->page_size; + if (vm->protected) { + gpgt_info->enc_mask = vm->arch.c_bit; + gpgt_info->shared_mask = vm->arch.s_bit; + } + list_for_each_entry(pgt_page_entry, &vm->pgt_pages, list) { + gpgt_info->paddrs[i] = pgt_page_entry->paddr; + i++; + } + TEST_ASSERT((i == vm->num_pgt_pages), "pgt entries mismatch with the counter"); + sync_vm_gpgt_info(vm, buf_start); +} + +void vm_map_page_table(struct kvm_vm *vm, vm_vaddr_t vaddr_min) +{ + struct pgt_page *pgt_page_entry; + vm_vaddr_t vaddr; + + /* Stop tracking further pgt pages, mapping pagetable may itself need + * new pages. + */ + vm->track_pgt_pages = false; + vm_vaddr_t vaddr_start = vm_vaddr_unused_gap(vm, + vm->num_pgt_pages * vm->page_size, vaddr_min); + vaddr = vaddr_start; + list_for_each_entry(pgt_page_entry, &vm->pgt_pages, list) { + /* Map the virtual page. */ + virt_pg_map(vm, vaddr, pgt_page_entry->paddr & ~vm->arch.c_bit); + sparsebit_set(vm->vpages_mapped, vaddr >> vm->page_shift); + vaddr += vm->page_size; + } + vm->pgt_vaddr_start = vaddr_start; + + vm_setup_pgt_info_buf(vm, vaddr_min); +} + /* * VM Virtual Address Allocate Shared/Encrypted * @@ -1981,9 +2052,24 @@ vm_paddr_t vm_phy_page_alloc(struct kvm_vm *vm, vm_paddr_t paddr_min, /* Arbitrary minimum physical address used for virtual translation tables. */ #define KVM_GUEST_PAGE_TABLE_MIN_PADDR 0x180000 +void vm_set_pgt_alloc_tracking(struct kvm_vm *vm) +{ + vm->track_pgt_pages = true; +} + vm_paddr_t vm_alloc_page_table(struct kvm_vm *vm) { - return vm_phy_page_alloc(vm, KVM_GUEST_PAGE_TABLE_MIN_PADDR, 0); + struct pgt_page *pgt; + vm_paddr_t paddr = vm_phy_page_alloc(vm, KVM_GUEST_PAGE_TABLE_MIN_PADDR, 0); + + if (vm->track_pgt_pages) { + pgt = calloc(1, sizeof(*pgt)); + TEST_ASSERT(pgt != NULL, "Insufficient memory"); + pgt->paddr = (paddr | vm->arch.c_bit); + list_add(&pgt->list, &vm->pgt_pages); + vm->num_pgt_pages++; + } + return paddr; } /* diff --git a/tools/testing/selftests/kvm/lib/x86_64/processor.c b/tools/testing/selftests/kvm/lib/x86_64/processor.c index 429e55f2609f..ab7d4cc4b848 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/processor.c +++ b/tools/testing/selftests/kvm/lib/x86_64/processor.c @@ -19,6 +19,7 @@ #define MAX_NR_CPUID_ENTRIES 100 vm_vaddr_t exception_handlers; +static struct guest_pgt_info *gpgt_info; static bool is_cpu_vendor_intel; static bool is_cpu_vendor_amd; @@ -241,6 +242,46 @@ void virt_arch_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr) __virt_pg_map(vm, vaddr, paddr, PG_LEVEL_4K); } +static uint64_t *guest_code_get_pte(uint64_t vaddr) +{ + uint16_t index[4]; + uint64_t *pml4e, *pdpe, *pde, *pte; + uint64_t pgt_paddr = get_cr3(); + + GUEST_ASSERT(gpgt_info != NULL); + uint64_t page_size = gpgt_info->page_size; + + index[0] = (vaddr >> 12) & 0x1ffu; + index[1] = (vaddr >> 21) & 0x1ffu; + index[2] = (vaddr >> 30) & 0x1ffu; + index[3] = (vaddr >> 39) & 0x1ffu; + + pml4e = guest_code_get_pgt_vaddr(gpgt_info, pgt_paddr); + GUEST_ASSERT(pml4e && (pml4e[index[3]] & PTE_PRESENT_MASK)); + + pgt_paddr = (PTE_GET_PFN(pml4e[index[3]]) * page_size); + pdpe = guest_code_get_pgt_vaddr(gpgt_info, pgt_paddr); + GUEST_ASSERT(pdpe && (pdpe[index[2]] & PTE_PRESENT_MASK) && + !(pdpe[index[2]] & PTE_LARGE_MASK)); + + pgt_paddr = (PTE_GET_PFN(pdpe[index[2]]) * page_size); + pde = guest_code_get_pgt_vaddr(gpgt_info, pgt_paddr); + GUEST_ASSERT(pde && (pde[index[1]] & PTE_PRESENT_MASK) && + !(pde[index[1]] & PTE_LARGE_MASK)); + + pgt_paddr = (PTE_GET_PFN(pde[index[1]]) * page_size); + pte = guest_code_get_pgt_vaddr(gpgt_info, pgt_paddr); + GUEST_ASSERT(pte && (pte[index[0]] & PTE_PRESENT_MASK)); + + return (uint64_t *)&pte[index[0]]; +} + +void sync_vm_gpgt_info(struct kvm_vm *vm, vm_vaddr_t pgt_info) +{ + gpgt_info = (struct guest_pgt_info *)pgt_info; + sync_global_to_guest(vm, gpgt_info); +} + void virt_map_level(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr, uint64_t nr_bytes, int level) { From patchwork Fri Dec 23 00:13:47 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Vishal Annapurve X-Patchwork-Id: 36022 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:adf:e747:0:0:0:0:0 with SMTP id c7csp55697wrn; Thu, 22 Dec 2022 16:15:01 -0800 (PST) X-Google-Smtp-Source: AMrXdXsIOdea0O9AgutesxSjI4VK4BxE+ab165Rzs30FB9oQabrR2WzPAoA0xCWMD+3oltoQHtKA X-Received: by 2002:a05:6a20:a59a:b0:9d:efbf:7864 with SMTP id bc26-20020a056a20a59a00b0009defbf7864mr10305397pzb.25.1671754501645; Thu, 22 Dec 2022 16:15:01 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1671754501; cv=none; d=google.com; s=arc-20160816; b=SfnHvm6Id+rtGtM0wUEoI7c0de27KKkPwh77lr/eYkzyHdMqWy2O7xTJjwZxY/06n7 fKvNFvQ+A7OvWHinM1RjynoDLP3aCZgeS9ZZl0SeCpfN14fcpfbAxeL3PabjWZ/TifBt hkwhslKcEgjzoSvXPFAct5WsFr2wE4Pj0BVbNoVo3LvzOMUfQEwii81+FJfLwsK9Rqnu VSI+Pj+1rsd3TaYBOZi+TAfencnYSZXPSRj0ZdGB4lb9NKpRM6/HDmBb/2CU9BWtui5J uyfd2HRi5aUFgGxxKsR+GIgI36lHwS92flueDY+rLFtNZPGO2Zi60DYjIDmb4fWUZqWG OT5Q== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:dkim-signature; bh=cLuChDmHZy9fZJAsWYadyMA42cALgM97d3TAhY29bd4=; b=sq8LMzk2A20hbITrgpO6IryU337GF9vdt3vI0atwbGZgcAqmzpeNKjFJD0K+0Fm9qj qxR3XnMNVvVIGNB6BCF0MaF/4K2Qf6jM/QGYhT/PRtDbQV8D0JmdGcrCgZYc7mmDIVqm TPbo2Os4YJXnjazfQ/yZ3ZyN60/quRxV0XD86YwW5y10JFixKrErzQXFFfSBF/NvNu3G kethNyB9B5TTGX1zRKmIqJk/S7BQKuvzhw5IKyCeid3xVR6MlK6udbt5X8/p10rXc6/t +sSDH+bUQGY7P9XSEf9j9fClQLqmco/QQHTHepie4Gr3BVHjABRNqaXML29O9DcU7U0h dyNQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=qesxOioX; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id j6-20020a63cf06000000b00495c911341bsi1091668pgg.783.2022.12.22.16.14.48; Thu, 22 Dec 2022 16:15:01 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=qesxOioX; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235500AbiLWAOQ (ORCPT + 99 others); Thu, 22 Dec 2022 19:14:16 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44546 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230457AbiLWAOD (ORCPT ); Thu, 22 Dec 2022 19:14:03 -0500 Received: from mail-pj1-x1049.google.com (mail-pj1-x1049.google.com [IPv6:2607:f8b0:4864:20::1049]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C3B3326AC2 for ; Thu, 22 Dec 2022 16:14:02 -0800 (PST) Received: by mail-pj1-x1049.google.com with SMTP id il11-20020a17090b164b00b00219a4366109so3968907pjb.0 for ; Thu, 22 Dec 2022 16:14:02 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=cLuChDmHZy9fZJAsWYadyMA42cALgM97d3TAhY29bd4=; b=qesxOioXaSBJL1ruAcCimnE/4E3MkzM5ZdGrQ40tnDmX4p1zgoouiyYp1MUFj51vYO nNfOwW6LG4WVVZlUPnlDY4+m1g5Ot+S+a+sxVijlNBf3A1ztamoTbu1JNeB6zcat62bv 4sZKS+O6SR4BDGU2SdZQmbQddafokLgtJEAamTcU9EXpGLpzv5QpwfcuaDT1U1ByTR8t Yn9Pel1JcW6C3LxBscnyfw+zgkMrzXFOvu0/lfQMKNp1hjPCg42eLccXB6PKdZ97pd5/ 03ryjbSSeYTi7TOD9AP2l+5tIQA4MenYW7GXMmsAvoZ+uhGJvLzF654L0FA35u/haI3Y 1Q2A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=cLuChDmHZy9fZJAsWYadyMA42cALgM97d3TAhY29bd4=; b=H6d7VGF+05cg5PSvO59chYQTH7WdZxn3Tz98c9M/GMsqiIAE1cc3Wfydc4PlkcPJhu y6Vsvpf71onUcQnCaceN9TA6gjsVuu0/TzcplPKIy1bHk3IiXtLvvqI2+ryIi9gjneph pOKdFEAAknVAtPPMp6OkegTeJX88qtr0urIyl/yvMbFmoBPxgKEN2vCjjPj+qVnvED8p Oc+1ZXbyCNeU6FMeaJKj8TdKfw4lsuy83zDNUzMEBJS2YcmZvHlfQrlLewJ6JsQkSerm CmPLo6M3lm3zpNAKAFhR9aCYclYwY9+UtFyLYIAE03jGvIuoeWYUUn1uyVpQW2rm+kgn AwoQ== X-Gm-Message-State: AFqh2kooKyPNaJ71Ydf2yfnR5inzTCJm3yo3NCQrGnWkCsTEVuh9e0cu Wh3+iF3pUDCV1qhOqa8F2oBrvX98t8MK0F0h X-Received: from vannapurve2.c.googlers.com ([fda3:e722:ac3:cc00:7f:e700:c0a8:41f8]) (user=vannapurve job=sendgmr) by 2002:aa7:870f:0:b0:576:a1d3:a157 with SMTP id b15-20020aa7870f000000b00576a1d3a157mr451723pfo.32.1671754442064; Thu, 22 Dec 2022 16:14:02 -0800 (PST) Date: Fri, 23 Dec 2022 00:13:47 +0000 In-Reply-To: <20221223001352.3873203-1-vannapurve@google.com> Mime-Version: 1.0 References: <20221223001352.3873203-1-vannapurve@google.com> X-Mailer: git-send-email 2.39.0.314.g84b9a713c41-goog Message-ID: <20221223001352.3873203-4-vannapurve@google.com> Subject: [V3 PATCH 3/8] KVM: selftests: x86: Support changing gpa encryption masks From: Vishal Annapurve To: x86@kernel.org, kvm@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org Cc: pbonzini@redhat.com, vkuznets@redhat.com, wanpengli@tencent.com, jmattson@google.com, joro@8bytes.org, tglx@linutronix.de, mingo@redhat.com, bp@alien8.de, dave.hansen@linux.intel.com, hpa@zytor.com, shuah@kernel.org, yang.zhong@intel.com, drjones@redhat.com, ricarkol@google.com, aaronlewis@google.com, wei.w.wang@intel.com, kirill.shutemov@linux.intel.com, corbet@lwn.net, hughd@google.com, jlayton@kernel.org, bfields@fieldses.org, akpm@linux-foundation.org, chao.p.peng@linux.intel.com, yu.c.zhang@linux.intel.com, jun.nakajima@intel.com, dave.hansen@intel.com, michael.roth@amd.com, qperret@google.com, steven.price@arm.com, ak@linux.intel.com, david@redhat.com, luto@kernel.org, vbabka@suse.cz, marcorr@google.com, erdemaktas@google.com, pgonda@google.com, nikunj@amd.com, seanjc@google.com, diviness@google.com, maz@kernel.org, dmatlack@google.com, axelrasmussen@google.com, maciej.szmigiero@oracle.com, mizhang@google.com, bgardon@google.com, ackerleytng@google.com, Vishal Annapurve X-Spam-Status: No, score=-9.6 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_NONE, SPF_HELO_NONE,SPF_PASS,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1752961648035275865?= X-GMAIL-MSGID: =?utf-8?q?1752961648035275865?= Add support for guest side functionality to modify encryption/shared masks for entries in page table to allow accessing GPA ranges as private or shared. Signed-off-by: Vishal Annapurve --- .../selftests/kvm/include/x86_64/processor.h | 4 ++ .../selftests/kvm/lib/x86_64/processor.c | 39 +++++++++++++++++++ 2 files changed, 43 insertions(+) diff --git a/tools/testing/selftests/kvm/include/x86_64/processor.h b/tools/testing/selftests/kvm/include/x86_64/processor.h index 3617f83bb2e5..c8c55f54c14f 100644 --- a/tools/testing/selftests/kvm/include/x86_64/processor.h +++ b/tools/testing/selftests/kvm/include/x86_64/processor.h @@ -945,6 +945,10 @@ void vcpu_init_descriptor_tables(struct kvm_vcpu *vcpu); void vm_install_exception_handler(struct kvm_vm *vm, int vector, void (*handler)(struct ex_regs *)); +void guest_set_region_shared(void *vaddr, uint64_t size); + +void guest_set_region_private(void *vaddr, uint64_t size); + /* If a toddler were to say "abracadabra". */ #define KVM_EXCEPTION_MAGIC 0xabacadabaULL diff --git a/tools/testing/selftests/kvm/lib/x86_64/processor.c b/tools/testing/selftests/kvm/lib/x86_64/processor.c index ab7d4cc4b848..42d1e4074f32 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/processor.c +++ b/tools/testing/selftests/kvm/lib/x86_64/processor.c @@ -276,6 +276,45 @@ static uint64_t *guest_code_get_pte(uint64_t vaddr) return (uint64_t *)&pte[index[0]]; } +static void guest_code_change_region_prot(void *vaddr_start, uint64_t mem_size, + bool private) +{ + uint64_t vaddr = (uint64_t)vaddr_start; + uint32_t num_pages; + + GUEST_ASSERT(gpgt_info != NULL); + uint32_t guest_page_size = gpgt_info->page_size; + + GUEST_ASSERT(!(mem_size % guest_page_size) && !(vaddr % guest_page_size)); + GUEST_ASSERT(gpgt_info->enc_mask | gpgt_info->shared_mask); + + num_pages = mem_size / guest_page_size; + for (uint32_t i = 0; i < num_pages; i++) { + uint64_t *pte = guest_code_get_pte(vaddr); + + GUEST_ASSERT(pte); + if (private) { + *pte &= ~(gpgt_info->shared_mask); + *pte |= gpgt_info->enc_mask; + } else { + *pte &= ~(gpgt_info->enc_mask); + *pte |= gpgt_info->shared_mask; + } + asm volatile("invlpg (%0)" :: "r"(vaddr) : "memory"); + vaddr += guest_page_size; + } +} + +void guest_set_region_shared(void *vaddr, uint64_t size) +{ + guest_code_change_region_prot(vaddr, size, /* shared */ false); +} + +void guest_set_region_private(void *vaddr, uint64_t size) +{ + guest_code_change_region_prot(vaddr, size, /* private */ true); +} + void sync_vm_gpgt_info(struct kvm_vm *vm, vm_vaddr_t pgt_info) { gpgt_info = (struct guest_pgt_info *)pgt_info; From patchwork Fri Dec 23 00:13:48 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Vishal Annapurve X-Patchwork-Id: 36021 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:adf:e747:0:0:0:0:0 with SMTP id c7csp55689wrn; Thu, 22 Dec 2022 16:15:00 -0800 (PST) X-Google-Smtp-Source: AMrXdXuMAkDWu22cxilBW/Z8oJ0bhSC648EhW6+Dm0nU6kMjumaCOPPEiOsdhMTI2AD6KBMeBUR4 X-Received: by 2002:a05:6a20:a682:b0:af:fcb6:2ef6 with SMTP id ba2-20020a056a20a68200b000affcb62ef6mr11634011pzb.23.1671754500416; Thu, 22 Dec 2022 16:15:00 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1671754500; cv=none; d=google.com; s=arc-20160816; b=uWsZU/cskrjevDDdrQb6/4FJRSdwg3tbfutt/0eMHTOZymqgI20YAsQ7QsOgKEbqAT ErnulS6ARVbLAi2hZ13GFFkaXdO+mR3AMHigqspLTOjXBC24zBSFGOj+bsW9j90tkYiT ICYSKSzN+G+lZuir4fhQPokl+3adrThLYUdwhLE+jEKMji5W//Hg3EJUnfjLIi8F+MUo 1v6Pi15K5aXoxHss6dEzIsJqLd7gr0sF6wIKfVGdCsZ1nfBfbK8+FCLiQRCvDaCPlNA/ OFuHWsZUVjeW0pAiM89XF0dT71R8gRYK8vDxJU0JB+oSU5VSv1qERQ2XvjIy4dcNLiWa AT5A== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:dkim-signature; bh=xlm4N5CTIk+gx1iR2xF2yQo3rvmps98CLQF90zWQYoY=; b=PoN02MXKlWFR/RGfKyGe7a419MYkubjSzeK97gi/0x3ZYTe8/wTbaecapldiRj4faY Fkap+EoodNk/MZp8av4Q+ACd3XNFoYDg20H5MVISH8xfprtVF+jbDFdK5F2Uf4uLxW2T LDkZrogVHuW+TDCsPb0kZOQ1E2TIMSpTuANTVKejyDSvk4DJZvKC3O6hF9aFeuVR89mq KDv4lTi8+umzySD31IoDJl4BGRZ+w4JBWQSBoNoDllE2IinDhS5e0n5fuRVGOsOC+Rqq Y8mqCACet2/4ONkvsMrBY7ERPRTMGqjzWwlPBTissHrAqGnmR/cqviwLH6Mbs8P61YL/ 7ZBg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=jq9yJkP+; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id 21-20020a631355000000b0046ec7b397e1si2034773pgt.759.2022.12.22.16.14.47; Thu, 22 Dec 2022 16:15:00 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=jq9yJkP+; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235730AbiLWAOU (ORCPT + 99 others); Thu, 22 Dec 2022 19:14:20 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44646 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235443AbiLWAOF (ORCPT ); Thu, 22 Dec 2022 19:14:05 -0500 Received: from mail-pj1-x104a.google.com (mail-pj1-x104a.google.com [IPv6:2607:f8b0:4864:20::104a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0B66028705 for ; Thu, 22 Dec 2022 16:14:05 -0800 (PST) Received: by mail-pj1-x104a.google.com with SMTP id h6-20020a17090aa88600b00223fccff2efso3940718pjq.6 for ; Thu, 22 Dec 2022 16:14:05 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=xlm4N5CTIk+gx1iR2xF2yQo3rvmps98CLQF90zWQYoY=; b=jq9yJkP+aFqI9u8i8zl7BZbwNgH9lWiHnMROFDPqV7emq/6CZ1BBaf50MTKk4axAHc P9sABC18Xnp2N7bHZ4fpyynjIqDrHu6Gm9tsTlRRzSwwn3W0i3ulLy0Xl61kd3MxS1Sb 2NHztbMkbWmYzJGnjb2t3WQGs6TpLSrUBIBYBU8VNN912lCHyUFwtnC5bk9HsB8Ggfis +y7p+8FCdWi7jdfSSDQNlmCl+FJTT2KJdcPfFDlhmohQqs3qvR9KClcOBwCwtol5jTBA 0rS1T8RuAY6ZCMdhuzRsWhPMXMYwBH531gG+eFKkv7DZNMnSsCUeFcAWqVBQ6TTT5aix XKRw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=xlm4N5CTIk+gx1iR2xF2yQo3rvmps98CLQF90zWQYoY=; b=JCifJ9v5AieusW65AvpCaQrof3u3dfWiHJBjaYqtkmhg3L/YxmfLdegzdjN5bJwhlD endckrIeMq0n4r4YFNIhFw2rh/vRezQuc/QLeUL5ytnew31dSPGUSdtO46FUTeqrsNQ4 YOWDQgMHMcxHAL11eg+QB/Rc2/IbsrsF+dLG5pRaW89OGrmCjJg907uQpxA0LYJi9oQI m5xLizOIJFjOGRQVs4Eqp0UgrTCREyO99apN5o+F0e0vTw8/KhuuYRh86Sm0HiHDp4l4 oloLvYnmXvCUQnCZjabT+5FTlIxmLP1zyiemOJY26IZp/aHWQ8gjTNeIqqv0e7IUFUMH BJBQ== X-Gm-Message-State: AFqh2kpA/Ce9LoUpQ3Q3yEzAktozTXw8wzkE/F7OqADh/8lFeByHY8a/ 6sNshflhkzJSKnhS2TiPe/SwjIpRzfdMaSvs X-Received: from vannapurve2.c.googlers.com ([fda3:e722:ac3:cc00:7f:e700:c0a8:41f8]) (user=vannapurve job=sendgmr) by 2002:a17:903:32c3:b0:191:3e01:39b3 with SMTP id i3-20020a17090332c300b001913e0139b3mr400196plr.5.1671754444373; Thu, 22 Dec 2022 16:14:04 -0800 (PST) Date: Fri, 23 Dec 2022 00:13:48 +0000 In-Reply-To: <20221223001352.3873203-1-vannapurve@google.com> Mime-Version: 1.0 References: <20221223001352.3873203-1-vannapurve@google.com> X-Mailer: git-send-email 2.39.0.314.g84b9a713c41-goog Message-ID: <20221223001352.3873203-5-vannapurve@google.com> Subject: [V3 PATCH 4/8] KVM: selftests: Split SEV VM creation logic From: Vishal Annapurve To: x86@kernel.org, kvm@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org Cc: pbonzini@redhat.com, vkuznets@redhat.com, wanpengli@tencent.com, jmattson@google.com, joro@8bytes.org, tglx@linutronix.de, mingo@redhat.com, bp@alien8.de, dave.hansen@linux.intel.com, hpa@zytor.com, shuah@kernel.org, yang.zhong@intel.com, drjones@redhat.com, ricarkol@google.com, aaronlewis@google.com, wei.w.wang@intel.com, kirill.shutemov@linux.intel.com, corbet@lwn.net, hughd@google.com, jlayton@kernel.org, bfields@fieldses.org, akpm@linux-foundation.org, chao.p.peng@linux.intel.com, yu.c.zhang@linux.intel.com, jun.nakajima@intel.com, dave.hansen@intel.com, michael.roth@amd.com, qperret@google.com, steven.price@arm.com, ak@linux.intel.com, david@redhat.com, luto@kernel.org, vbabka@suse.cz, marcorr@google.com, erdemaktas@google.com, pgonda@google.com, nikunj@amd.com, seanjc@google.com, diviness@google.com, maz@kernel.org, dmatlack@google.com, axelrasmussen@google.com, maciej.szmigiero@oracle.com, mizhang@google.com, bgardon@google.com, ackerleytng@google.com, Vishal Annapurve X-Spam-Status: No, score=-9.6 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_NONE, SPF_HELO_NONE,SPF_PASS,USER_IN_DEF_DKIM_WL autolearn=unavailable autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1752961647202950803?= X-GMAIL-MSGID: =?utf-8?q?1752961647202950803?= Split SEV VM creation logic to allow additional modifications to SEV VM configuration e.g. adding memslots. Signed-off-by: Vishal Annapurve --- .../selftests/kvm/include/x86_64/sev.h | 4 ++++ tools/testing/selftests/kvm/lib/x86_64/sev.c | 20 ++++++++++++++++--- 2 files changed, 21 insertions(+), 3 deletions(-) diff --git a/tools/testing/selftests/kvm/include/x86_64/sev.h b/tools/testing/selftests/kvm/include/x86_64/sev.h index 1148db928d0b..6bf2015fff7a 100644 --- a/tools/testing/selftests/kvm/include/x86_64/sev.h +++ b/tools/testing/selftests/kvm/include/x86_64/sev.h @@ -19,4 +19,8 @@ bool is_kvm_sev_supported(void); struct kvm_vm *vm_sev_create_with_one_vcpu(uint32_t policy, void *guest_code, struct kvm_vcpu **cpu); +struct kvm_vm *sev_vm_init_with_one_vcpu(uint32_t policy, void *guest_code, + struct kvm_vcpu **cpu); + +void sev_vm_finalize(struct kvm_vm *vm, uint32_t policy); #endif /* SELFTEST_KVM_SEV_H */ diff --git a/tools/testing/selftests/kvm/lib/x86_64/sev.c b/tools/testing/selftests/kvm/lib/x86_64/sev.c index 49c62f25363e..96d3dbc2ba74 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/sev.c +++ b/tools/testing/selftests/kvm/lib/x86_64/sev.c @@ -215,7 +215,7 @@ static void sev_vm_measure(struct kvm_vm *vm) pr_debug("\n"); } -struct kvm_vm *vm_sev_create_with_one_vcpu(uint32_t policy, void *guest_code, +struct kvm_vm *sev_vm_init_with_one_vcpu(uint32_t policy, void *guest_code, struct kvm_vcpu **cpu) { enum vm_guest_mode mode = VM_MODE_PXXV48_4K; @@ -231,14 +231,28 @@ struct kvm_vm *vm_sev_create_with_one_vcpu(uint32_t policy, void *guest_code, *cpu = vm_vcpu_add(vm, 0, guest_code); kvm_vm_elf_load(vm, program_invocation_name); + pr_info("SEV guest created, policy: 0x%x, size: %lu KB\n", policy, + nr_pages * vm->page_size / 1024); + return vm; +} + +void sev_vm_finalize(struct kvm_vm *vm, uint32_t policy) +{ sev_vm_launch(vm, policy); sev_vm_measure(vm); sev_vm_launch_finish(vm); +} - pr_info("SEV guest created, policy: 0x%x, size: %lu KB\n", policy, - nr_pages * vm->page_size / 1024); +struct kvm_vm *vm_sev_create_with_one_vcpu(uint32_t policy, void *guest_code, + struct kvm_vcpu **cpu) +{ + struct kvm_vm *vm; + + vm = sev_vm_init_with_one_vcpu(policy, guest_code, cpu); + + sev_vm_finalize(vm, policy); return vm; } From patchwork Fri Dec 23 00:13:49 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Vishal Annapurve X-Patchwork-Id: 36023 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:adf:e747:0:0:0:0:0 with SMTP id c7csp55722wrn; Thu, 22 Dec 2022 16:15:06 -0800 (PST) X-Google-Smtp-Source: AMrXdXuSkzP+/18sFFfmBOEF0XbEG5qjBodek+URKCA8pdyXldPe4pmhXilWRT10JuLkvlAIvaiI X-Received: by 2002:a17:902:ea02:b0:189:38a1:8c04 with SMTP id s2-20020a170902ea0200b0018938a18c04mr27017573plg.50.1671754506504; Thu, 22 Dec 2022 16:15:06 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1671754506; cv=none; d=google.com; s=arc-20160816; b=Coc/zR7rfLyZjFKKnA2j8AqNDuQaq/sTMOZMapIFLQHJL4/8bV0kwdDgsmxv7iSc5i fr+kr1NO/ehaiR2BbXfFwjPCYK0uXauP2Ib+vdazNnARqPGWRDX+VFhn5FNiLqMj5iMo 9H5xVJ1CBowLXTL46+ZrZim9n/TuVLzQFirb4pI3dZYFnVgBsID9YhMWoF1YjvfbiOOd kg7N8UKeP1D/kFe6sUqmw7lFzLWmqouL1vTofp1aP54KUQoAJS9BYZtB86tz4zETpy74 dqUdU8XOhCPBzpghWiJkXDKi6YT1iIF7QwJiG9rqZOdc37TA59m/5V8V+xwr+vk5Hlev hfSg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:dkim-signature; bh=EZopER/s4tiFrvreBNvA+OQLVRUFqUiISvcp+c+5UHk=; b=FCI3/RjsRbI1ZUuHo2t6a+sXB9vBU8VWbY7BZ6Pj2VScpnJ/eXuTCaup1ihc1F/QI3 y9w7ZHQkwIzmK2W9OJ7S6Enmu79zlIQR1vuip4M2DyX4u9weVQf98Z0paIiSN+clOEHT htUfZ2EZOwVIoy/lOULIHh/eFaaNTbmEiXG5N6UZl+y/Uo2yBApIp6r3nKM8JKWCDSa9 XAz2atb7NJSe9DPLphzxmgHwVOzYeFahkDrVrn+oHnmHKY8rvC7ZDGQft94L38DWmChn 7iFb8jQsQCCKyUU9TaDbTVUwIg5JeQvaURQZe1Ys76Y5swxlroDJoUHHdidLsBRx6Ybe WfPg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=HUHXH4BE; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id q15-20020a170902eb8f00b001869b988da6si1797402plg.402.2022.12.22.16.14.53; Thu, 22 Dec 2022 16:15:06 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=HUHXH4BE; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235788AbiLWAOe (ORCPT + 99 others); Thu, 22 Dec 2022 19:14:34 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44738 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235573AbiLWAOJ (ORCPT ); Thu, 22 Dec 2022 19:14:09 -0500 Received: from mail-pj1-x1049.google.com (mail-pj1-x1049.google.com [IPv6:2607:f8b0:4864:20::1049]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 61F6D2873B for ; Thu, 22 Dec 2022 16:14:07 -0800 (PST) Received: by mail-pj1-x1049.google.com with SMTP id me18-20020a17090b17d200b00219f8dc7cb3so3945759pjb.4 for ; Thu, 22 Dec 2022 16:14:07 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=EZopER/s4tiFrvreBNvA+OQLVRUFqUiISvcp+c+5UHk=; b=HUHXH4BEFdjasI8KjN0DUcFgQ332DM1EZL/VY94UC6Bde5YG+dsLST21wPEJeWfbWE wY4rri7V8MWRDYmpHskMTKvqqoxLZBtWuJC7SsHzFUIHkRoL0PTqLj7lSni34hAjQObJ xlXyImG913s4gNZ8WDm9+nM7U9HGJqblab9uMnFqkO+wPGJc1j5U63dgGp+POZhikZLP j/rXDR7gmy5jND0wk+OXc9YgUJodEbji4Jn4yijCKodYA82gSADK6f7xteIR75w0gdzX tsixo1K5xYhwzfwRZhv6jAu4TVv612TEO75bFQbxpJ3LOTl3mCEK6W07rf9eGXcjdcjY DPNA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=EZopER/s4tiFrvreBNvA+OQLVRUFqUiISvcp+c+5UHk=; b=eT00iv3ELABzGMjUd/UhT8wrfcIA7Vs4Y6qLGob0UMa50VA4colwarYdgqQNFX0dXU 0sZHSNek8Cs2jCuGrqKHM/H9lHZzWQAHaRFgSBQMbyNPDKmyEBtbnIyuHpcXOZYC/T58 sdXQx5taB5vH/XnqNKY02UTAe/dM/KquabZo4LY58JEGufaq3FtP0/mVbAYndvn5H9dL VU51+zKKBHuuZ9EhnbWtx7blyroF+tFJZzxclcic+bdTH9GH6BohOp0JjL2qnCROFsgs Wlj5wyScEBcda5Gg/C33vgLtCq9QT+wX1yldPJywY+7opLq2pIOy/u0DB56klAwUCYjq xz3A== X-Gm-Message-State: AFqh2ko+XrSwEbamS7sv8QyNFLacbics6QR9o5TWY5XHM5Itb4zPLNqW K6UQLw8VwAwjA8lvmDO+6fp/hZRFjl0ImZA1 X-Received: from vannapurve2.c.googlers.com ([fda3:e722:ac3:cc00:7f:e700:c0a8:41f8]) (user=vannapurve job=sendgmr) by 2002:a62:3042:0:b0:576:f200:210 with SMTP id w63-20020a623042000000b00576f2000210mr505612pfw.67.1671754446844; Thu, 22 Dec 2022 16:14:06 -0800 (PST) Date: Fri, 23 Dec 2022 00:13:49 +0000 In-Reply-To: <20221223001352.3873203-1-vannapurve@google.com> Mime-Version: 1.0 References: <20221223001352.3873203-1-vannapurve@google.com> X-Mailer: git-send-email 2.39.0.314.g84b9a713c41-goog Message-ID: <20221223001352.3873203-6-vannapurve@google.com> Subject: [V3 PATCH 5/8] KVM: selftests: Enable pagetable mapping for SEV VMs From: Vishal Annapurve To: x86@kernel.org, kvm@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org Cc: pbonzini@redhat.com, vkuznets@redhat.com, wanpengli@tencent.com, jmattson@google.com, joro@8bytes.org, tglx@linutronix.de, mingo@redhat.com, bp@alien8.de, dave.hansen@linux.intel.com, hpa@zytor.com, shuah@kernel.org, yang.zhong@intel.com, drjones@redhat.com, ricarkol@google.com, aaronlewis@google.com, wei.w.wang@intel.com, kirill.shutemov@linux.intel.com, corbet@lwn.net, hughd@google.com, jlayton@kernel.org, bfields@fieldses.org, akpm@linux-foundation.org, chao.p.peng@linux.intel.com, yu.c.zhang@linux.intel.com, jun.nakajima@intel.com, dave.hansen@intel.com, michael.roth@amd.com, qperret@google.com, steven.price@arm.com, ak@linux.intel.com, david@redhat.com, luto@kernel.org, vbabka@suse.cz, marcorr@google.com, erdemaktas@google.com, pgonda@google.com, nikunj@amd.com, seanjc@google.com, diviness@google.com, maz@kernel.org, dmatlack@google.com, axelrasmussen@google.com, maciej.szmigiero@oracle.com, mizhang@google.com, bgardon@google.com, ackerleytng@google.com, Vishal Annapurve X-Spam-Status: No, score=-9.6 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_NONE, SPF_HELO_NONE,SPF_PASS,USER_IN_DEF_DKIM_WL autolearn=unavailable autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1752961653368330763?= X-GMAIL-MSGID: =?utf-8?q?1752961653368330763?= Enable pagetable tracking and mapping for SEV VMs to allow guest code to execute guest_map_region_shared/private APIs. Signed-off-by: Vishal Annapurve --- tools/testing/selftests/kvm/lib/x86_64/sev.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tools/testing/selftests/kvm/lib/x86_64/sev.c b/tools/testing/selftests/kvm/lib/x86_64/sev.c index 96d3dbc2ba74..0dfffdc224d6 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/sev.c +++ b/tools/testing/selftests/kvm/lib/x86_64/sev.c @@ -215,6 +215,8 @@ static void sev_vm_measure(struct kvm_vm *vm) pr_debug("\n"); } +#define GUEST_PGT_MIN_VADDR 0x10000 + struct kvm_vm *sev_vm_init_with_one_vcpu(uint32_t policy, void *guest_code, struct kvm_vcpu **cpu) { @@ -224,6 +226,7 @@ struct kvm_vm *sev_vm_init_with_one_vcpu(uint32_t policy, void *guest_code, vm = ____vm_create(mode, nr_pages); + vm_set_pgt_alloc_tracking(vm); kvm_sev_ioctl(vm, KVM_SEV_INIT, NULL); configure_sev_pte_masks(vm); @@ -238,6 +241,8 @@ struct kvm_vm *sev_vm_init_with_one_vcpu(uint32_t policy, void *guest_code, void sev_vm_finalize(struct kvm_vm *vm, uint32_t policy) { + vm_map_page_table(vm, GUEST_PGT_MIN_VADDR); + sev_vm_launch(vm, policy); sev_vm_measure(vm); From patchwork Fri Dec 23 00:13:50 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Vishal Annapurve X-Patchwork-Id: 36024 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:adf:e747:0:0:0:0:0 with SMTP id c7csp55790wrn; Thu, 22 Dec 2022 16:15:18 -0800 (PST) X-Google-Smtp-Source: AMrXdXsflR5citZyymHicUTsQJXn1GWAiMwTGqBcY3FIqNHQlXSfB4Qs7sGdVE7qt3EH+bXoAppv X-Received: by 2002:a05:6a20:6699:b0:a7:e65:2b65 with SMTP id o25-20020a056a20669900b000a70e652b65mr9055151pzh.23.1671754518259; Thu, 22 Dec 2022 16:15:18 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1671754518; cv=none; d=google.com; s=arc-20160816; b=MjT+8+CmAeV6nolqTe+wNFOf39bAg6jZcRzXZ7Avt/OMFxerLmkjvMTKtGzOezipXE 7sDfCqD03dhR190Udswz5ihfWbuj0+81gAt2JyHLIYq0rhHFWPNMieq8IVT/L20b0/Iz hpPV/DRdAdiHTTUK6YzPYtWbFrjBtHILakzTrC47CLNTq0xcAkdLF7LuAVkEDMGktAiX qeD9X/qw1zhgsJT4SmzeNchC6NNX9TaEk+HuCwO7zXjn/t2FsYiGi5OUNc3ums/JOtHd tWeSLR9cDI+opZGz/eWGtVE6j25NerCHIhBgl/0pk02m5L4N+V8QOTpOhHyRVFZ3ZpIc oGBQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:dkim-signature; bh=DfG5JzhSPPBTmyeZqygfonNF3+eUcGyRu0K6yDYOFAo=; b=lpGB8qu40px+7IPAj82Yql2rwAMDdnNmzocsy0hZsJbVQUJZJSjgzliYeoHHWWT1aJ GAsYcUyDHDivaYN/T1vKpmC/REbU/TIlNd3nu1BvPxppq4YmZsf0JJGJNVPETjLTL4nf SyVs27GyoVcLP7BftbdhEztvrINHl2xDvygWGPaa5OSBzH9Vg+U1l4L6rBXCIQTOarat y9g2LmOEu0wrR335wrEorP1iuFn/fPhxSKGyEWN9bVk4vcA7vuUL9HDgQokdcRXL3tBK KqJpHTZ/5xqXXp9udipMFTSoNLzQ5sP1S5gSAV8toYNRMQtDyJKOFF0c27weSykKXHWp EP2g== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=SM4+xKni; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id 136-20020a63028e000000b0047071e220easi2140886pgc.634.2022.12.22.16.15.03; Thu, 22 Dec 2022 16:15:18 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=SM4+xKni; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235829AbiLWAOp (ORCPT + 99 others); Thu, 22 Dec 2022 19:14:45 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44546 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235708AbiLWAOT (ORCPT ); Thu, 22 Dec 2022 19:14:19 -0500 Received: from mail-pl1-x649.google.com (mail-pl1-x649.google.com [IPv6:2607:f8b0:4864:20::649]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2983826A93 for ; Thu, 22 Dec 2022 16:14:10 -0800 (PST) Received: by mail-pl1-x649.google.com with SMTP id z3-20020a170903018300b0018fb8ca1688so2324842plg.5 for ; Thu, 22 Dec 2022 16:14:10 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=DfG5JzhSPPBTmyeZqygfonNF3+eUcGyRu0K6yDYOFAo=; b=SM4+xKni226DpVhRn0NlBoUPPfriOG1H2UYRt16IbgCmpCE7yuX0JtitW2/sUsc3MJ /v0ne16UCwUCdgWvGj3qRXuEcilujaVVDmjG3codhksg+Oy4OleFYozdtiXrqznBYA3P Guyy3es8av6ciLytcA8Tw7UEANDlWCUDN2U5Z4tgNipzL8frjSSB2XHLi2AlmtTQ4pWh txpTtgar9LDSfDplgpjUttEesi1dSv79Tt1fSryGRU2Efr++lIuHRoSUICFmzFxLAyXA c2MtMSQv6A4vOxw7ZN0ob0IHH45SveGoCbCa6afIwm0yl3EUWRl8pT2+5Di12B5qQ94t oQ8A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=DfG5JzhSPPBTmyeZqygfonNF3+eUcGyRu0K6yDYOFAo=; b=4kZ+pBU3g0kv6O+/QKnKWet9Gg88Q1m97Wd/4n/QlnQJ7tAU0YyDL39OmJfEr/Nd9t 657Sa2KsSeCl9aNEgTnVau85EAqLGH6+rLKm9RpSVQVtreVuCWT2AXpT4YIvj3/fpbA+ 8AZTeIqrtQ9Pk932TfXsatcCDdp/jS/a59oYwywnSxfSbfCc+8MQcakqUI+M/+4Ar+VE /z2I9ExTSQCxSt1bx4+uTBj+a1iCVFNxX2KKfUabmPeX33kqrLlM6tjS5YrRgsbggM0C YSIpdo7aMbWy4eIgmVhSFGijFE1nw3CaVZQFn0vpMUo4p0ZVJIda3KE664SaMlp8VM+U NAJg== X-Gm-Message-State: AFqh2krllggq3TxtawJJ784+ymiyx/l3/YzMRdW6Y2q9sqOvo4XDqfsT K60v14m/bx5UN7Ldewmrr+LrCh0LfhaZaPw8 X-Received: from vannapurve2.c.googlers.com ([fda3:e722:ac3:cc00:7f:e700:c0a8:41f8]) (user=vannapurve job=sendgmr) by 2002:a17:90a:1309:b0:219:4487:f763 with SMTP id h9-20020a17090a130900b002194487f763mr845655pja.201.1671754449592; Thu, 22 Dec 2022 16:14:09 -0800 (PST) Date: Fri, 23 Dec 2022 00:13:50 +0000 In-Reply-To: <20221223001352.3873203-1-vannapurve@google.com> Mime-Version: 1.0 References: <20221223001352.3873203-1-vannapurve@google.com> X-Mailer: git-send-email 2.39.0.314.g84b9a713c41-goog Message-ID: <20221223001352.3873203-7-vannapurve@google.com> Subject: [V3 PATCH 6/8] KVM: selftests: Refactor private_mem_test From: Vishal Annapurve To: x86@kernel.org, kvm@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org Cc: pbonzini@redhat.com, vkuznets@redhat.com, wanpengli@tencent.com, jmattson@google.com, joro@8bytes.org, tglx@linutronix.de, mingo@redhat.com, bp@alien8.de, dave.hansen@linux.intel.com, hpa@zytor.com, shuah@kernel.org, yang.zhong@intel.com, drjones@redhat.com, ricarkol@google.com, aaronlewis@google.com, wei.w.wang@intel.com, kirill.shutemov@linux.intel.com, corbet@lwn.net, hughd@google.com, jlayton@kernel.org, bfields@fieldses.org, akpm@linux-foundation.org, chao.p.peng@linux.intel.com, yu.c.zhang@linux.intel.com, jun.nakajima@intel.com, dave.hansen@intel.com, michael.roth@amd.com, qperret@google.com, steven.price@arm.com, ak@linux.intel.com, david@redhat.com, luto@kernel.org, vbabka@suse.cz, marcorr@google.com, erdemaktas@google.com, pgonda@google.com, nikunj@amd.com, seanjc@google.com, diviness@google.com, maz@kernel.org, dmatlack@google.com, axelrasmussen@google.com, maciej.szmigiero@oracle.com, mizhang@google.com, bgardon@google.com, ackerleytng@google.com, Vishal Annapurve X-Spam-Status: No, score=-9.6 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_NONE, SPF_HELO_NONE,SPF_PASS,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1752961665958713500?= X-GMAIL-MSGID: =?utf-8?q?1752961665958713500?= Move most of the logic from private mem test to a library to allow possible sharing of private_mem_test logic amongst non-confidential and confidential VM selftests. Signed-off-by: Vishal Annapurve --- tools/testing/selftests/kvm/Makefile | 1 + .../include/x86_64/private_mem_test_helper.h | 15 ++ .../kvm/lib/x86_64/private_mem_test_helper.c | 197 ++++++++++++++++++ .../selftests/kvm/x86_64/private_mem_test.c | 187 +---------------- 4 files changed, 214 insertions(+), 186 deletions(-) create mode 100644 tools/testing/selftests/kvm/include/x86_64/private_mem_test_helper.h create mode 100644 tools/testing/selftests/kvm/lib/x86_64/private_mem_test_helper.c diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile index ee8c3aebee80..83c649c9de23 100644 --- a/tools/testing/selftests/kvm/Makefile +++ b/tools/testing/selftests/kvm/Makefile @@ -56,6 +56,7 @@ LIBKVM_x86_64 += lib/x86_64/handlers.S LIBKVM_x86_64 += lib/x86_64/hyperv.c LIBKVM_x86_64 += lib/x86_64/memstress.c LIBKVM_x86_64 += lib/x86_64/private_mem.c +LIBKVM_x86_64 += lib/x86_64/private_mem_test_helper.c LIBKVM_x86_64 += lib/x86_64/processor.c LIBKVM_x86_64 += lib/x86_64/svm.c LIBKVM_x86_64 += lib/x86_64/ucall.c diff --git a/tools/testing/selftests/kvm/include/x86_64/private_mem_test_helper.h b/tools/testing/selftests/kvm/include/x86_64/private_mem_test_helper.h new file mode 100644 index 000000000000..4d32c025876c --- /dev/null +++ b/tools/testing/selftests/kvm/include/x86_64/private_mem_test_helper.h @@ -0,0 +1,15 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (C) 2022, Google LLC. + */ + +#ifndef SELFTEST_KVM_PRIVATE_MEM_TEST_HELPER_H +#define SELFTEST_KVM_PRIVATE_MEM_TEST_HELPER_H + +#include +#include + +void execute_vm_with_private_test_mem( + enum vm_mem_backing_src_type test_mem_src); + +#endif /* SELFTEST_KVM_PRIVATE_MEM_TEST_HELPER_H */ diff --git a/tools/testing/selftests/kvm/lib/x86_64/private_mem_test_helper.c b/tools/testing/selftests/kvm/lib/x86_64/private_mem_test_helper.c new file mode 100644 index 000000000000..600bd21d1bb8 --- /dev/null +++ b/tools/testing/selftests/kvm/lib/x86_64/private_mem_test_helper.c @@ -0,0 +1,197 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2022, Google LLC. + */ +#define _GNU_SOURCE /* for program_invocation_short_name */ +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#define TEST_AREA_SLOT 10 +#define TEST_AREA_GPA 0xC0000000 +#define TEST_AREA_SIZE (2 * 1024 * 1024) +#define GUEST_TEST_MEM_OFFSET (1 * 1024 * 1024) +#define GUEST_TEST_MEM_SIZE (10 * 4096) + +#define VM_STAGE_PROCESSED(x) pr_info("Processed stage %s\n", #x) + +#define TEST_MEM_DATA_PATTERN1 0x66 +#define TEST_MEM_DATA_PATTERN2 0x99 +#define TEST_MEM_DATA_PATTERN3 0x33 +#define TEST_MEM_DATA_PATTERN4 0xaa +#define TEST_MEM_DATA_PATTERN5 0x12 + +static bool verify_mem_contents(void *mem, uint32_t size, uint8_t pattern) +{ + uint8_t *buf = (uint8_t *)mem; + + for (uint32_t i = 0; i < size; i++) { + if (buf[i] != pattern) + return false; + } + + return true; +} + +static void populate_test_area(void *test_area_base, uint64_t pattern) +{ + memset(test_area_base, pattern, TEST_AREA_SIZE); +} + +static void populate_guest_test_mem(void *guest_test_mem, uint64_t pattern) +{ + memset(guest_test_mem, pattern, GUEST_TEST_MEM_SIZE); +} + +static bool verify_test_area(void *test_area_base, uint64_t area_pattern, + uint64_t guest_pattern) +{ + void *guest_test_mem = test_area_base + GUEST_TEST_MEM_OFFSET; + void *test_area2_base = guest_test_mem + GUEST_TEST_MEM_SIZE; + uint64_t test_area2_size = (TEST_AREA_SIZE - (GUEST_TEST_MEM_OFFSET + + GUEST_TEST_MEM_SIZE)); + + return (verify_mem_contents(test_area_base, GUEST_TEST_MEM_OFFSET, area_pattern) && + verify_mem_contents(guest_test_mem, GUEST_TEST_MEM_SIZE, guest_pattern) && + verify_mem_contents(test_area2_base, test_area2_size, area_pattern)); +} + +#define GUEST_STARTED 0 +#define GUEST_PRIVATE_MEM_POPULATED 1 +#define GUEST_SHARED_MEM_POPULATED 2 +#define GUEST_PRIVATE_MEM_POPULATED2 3 + +/* + * Run memory conversion tests with explicit conversion: + * Execute KVM hypercall to map/unmap gpa range which will cause userspace exit + * to back/unback private memory. Subsequent accesses by guest to the gpa range + * will not cause exit to userspace. + * + * Test memory conversion scenarios with following steps: + * 1) Access private memory using private access and verify that memory contents + * are not visible to userspace. + * 2) Convert memory to shared using explicit conversions and ensure that + * userspace is able to access the shared regions. + * 3) Convert memory back to private using explicit conversions and ensure that + * userspace is again not able to access converted private regions. + */ +static void guest_conv_test_fn(void) +{ + void *test_area_base = (void *)TEST_AREA_GPA; + void *guest_test_mem = (void *)(TEST_AREA_GPA + GUEST_TEST_MEM_OFFSET); + uint64_t guest_test_size = GUEST_TEST_MEM_SIZE; + + GUEST_SYNC(GUEST_STARTED); + + populate_test_area(test_area_base, TEST_MEM_DATA_PATTERN1); + GUEST_SYNC(GUEST_PRIVATE_MEM_POPULATED); + GUEST_ASSERT(verify_test_area(test_area_base, TEST_MEM_DATA_PATTERN1, + TEST_MEM_DATA_PATTERN1)); + + kvm_hypercall_map_shared((uint64_t)guest_test_mem, guest_test_size); + + populate_guest_test_mem(guest_test_mem, TEST_MEM_DATA_PATTERN2); + + GUEST_SYNC(GUEST_SHARED_MEM_POPULATED); + GUEST_ASSERT(verify_test_area(test_area_base, TEST_MEM_DATA_PATTERN1, + TEST_MEM_DATA_PATTERN5)); + + kvm_hypercall_map_private((uint64_t)guest_test_mem, guest_test_size); + + populate_guest_test_mem(guest_test_mem, TEST_MEM_DATA_PATTERN3); + GUEST_SYNC(GUEST_PRIVATE_MEM_POPULATED2); + + GUEST_ASSERT(verify_test_area(test_area_base, TEST_MEM_DATA_PATTERN1, + TEST_MEM_DATA_PATTERN3)); + GUEST_DONE(); +} + +#define ASSERT_CONV_TEST_EXIT_IO(vcpu, stage) \ + { \ + struct ucall uc; \ + ASSERT_EQ(vcpu->run->exit_reason, KVM_EXIT_IO); \ + ASSERT_EQ(get_ucall(vcpu, &uc), UCALL_SYNC); \ + ASSERT_EQ(uc.args[1], stage); \ + } + +#define ASSERT_GUEST_DONE(vcpu) \ + { \ + struct ucall uc; \ + ASSERT_EQ(vcpu->run->exit_reason, KVM_EXIT_IO); \ + ASSERT_EQ(get_ucall(vcpu, &uc), UCALL_DONE); \ + } + +static void host_conv_test_fn(struct kvm_vm *vm, struct kvm_vcpu *vcpu) +{ + void *test_area_hva = addr_gpa2hva(vm, TEST_AREA_GPA); + void *guest_test_mem_hva = (test_area_hva + GUEST_TEST_MEM_OFFSET); + + vcpu_run_and_handle_mapgpa(vm, vcpu); + ASSERT_CONV_TEST_EXIT_IO(vcpu, GUEST_STARTED); + populate_test_area(test_area_hva, TEST_MEM_DATA_PATTERN4); + VM_STAGE_PROCESSED(GUEST_STARTED); + + vcpu_run_and_handle_mapgpa(vm, vcpu); + ASSERT_CONV_TEST_EXIT_IO(vcpu, GUEST_PRIVATE_MEM_POPULATED); + TEST_ASSERT(verify_test_area(test_area_hva, TEST_MEM_DATA_PATTERN4, + TEST_MEM_DATA_PATTERN4), "failed"); + VM_STAGE_PROCESSED(GUEST_PRIVATE_MEM_POPULATED); + + vcpu_run_and_handle_mapgpa(vm, vcpu); + ASSERT_CONV_TEST_EXIT_IO(vcpu, GUEST_SHARED_MEM_POPULATED); + TEST_ASSERT(verify_test_area(test_area_hva, TEST_MEM_DATA_PATTERN4, + TEST_MEM_DATA_PATTERN2), "failed"); + populate_guest_test_mem(guest_test_mem_hva, TEST_MEM_DATA_PATTERN5); + VM_STAGE_PROCESSED(GUEST_SHARED_MEM_POPULATED); + + vcpu_run_and_handle_mapgpa(vm, vcpu); + ASSERT_CONV_TEST_EXIT_IO(vcpu, GUEST_PRIVATE_MEM_POPULATED2); + TEST_ASSERT(verify_test_area(test_area_hva, TEST_MEM_DATA_PATTERN4, + TEST_MEM_DATA_PATTERN5), "failed"); + VM_STAGE_PROCESSED(GUEST_PRIVATE_MEM_POPULATED2); + + vcpu_run_and_handle_mapgpa(vm, vcpu); + ASSERT_GUEST_DONE(vcpu); +} + +void execute_vm_with_private_test_mem( + enum vm_mem_backing_src_type test_mem_src) +{ + struct kvm_vm *vm; + struct kvm_enable_cap cap; + struct kvm_vcpu *vcpu; + + vm = vm_create_with_one_vcpu(&vcpu, guest_conv_test_fn); + + vm_check_cap(vm, KVM_CAP_EXIT_HYPERCALL); + cap.cap = KVM_CAP_EXIT_HYPERCALL; + cap.flags = 0; + cap.args[0] = (1 << KVM_HC_MAP_GPA_RANGE); + vm_ioctl(vm, KVM_ENABLE_CAP, &cap); + + vm_userspace_mem_region_add(vm, test_mem_src, TEST_AREA_GPA, + TEST_AREA_SLOT, TEST_AREA_SIZE / vm->page_size, KVM_MEM_PRIVATE); + vm_allocate_private_mem(vm, TEST_AREA_GPA, TEST_AREA_SIZE); + + virt_map(vm, TEST_AREA_GPA, TEST_AREA_GPA, TEST_AREA_SIZE/vm->page_size); + + host_conv_test_fn(vm, vcpu); + + kvm_vm_free(vm); +} diff --git a/tools/testing/selftests/kvm/x86_64/private_mem_test.c b/tools/testing/selftests/kvm/x86_64/private_mem_test.c index 015ada2e3d54..72c2f913ee92 100644 --- a/tools/testing/selftests/kvm/x86_64/private_mem_test.c +++ b/tools/testing/selftests/kvm/x86_64/private_mem_test.c @@ -3,197 +3,12 @@ * Copyright (C) 2022, Google LLC. */ #define _GNU_SOURCE /* for program_invocation_short_name */ -#include -#include -#include -#include #include #include #include -#include -#include -#include -#include -#include - -#include #include -#include -#include - -#define TEST_AREA_SLOT 10 -#define TEST_AREA_GPA 0xC0000000 -#define TEST_AREA_SIZE (2 * 1024 * 1024) -#define GUEST_TEST_MEM_OFFSET (1 * 1024 * 1024) -#define GUEST_TEST_MEM_SIZE (10 * 4096) - -#define VM_STAGE_PROCESSED(x) pr_info("Processed stage %s\n", #x) - -#define TEST_MEM_DATA_PATTERN1 0x66 -#define TEST_MEM_DATA_PATTERN2 0x99 -#define TEST_MEM_DATA_PATTERN3 0x33 -#define TEST_MEM_DATA_PATTERN4 0xaa -#define TEST_MEM_DATA_PATTERN5 0x12 - -static bool verify_mem_contents(void *mem, uint32_t size, uint8_t pattern) -{ - uint8_t *buf = (uint8_t *)mem; - - for (uint32_t i = 0; i < size; i++) { - if (buf[i] != pattern) - return false; - } - - return true; -} - -static void populate_test_area(void *test_area_base, uint64_t pattern) -{ - memset(test_area_base, pattern, TEST_AREA_SIZE); -} - -static void populate_guest_test_mem(void *guest_test_mem, uint64_t pattern) -{ - memset(guest_test_mem, pattern, GUEST_TEST_MEM_SIZE); -} - -static bool verify_test_area(void *test_area_base, uint64_t area_pattern, - uint64_t guest_pattern) -{ - void *guest_test_mem = test_area_base + GUEST_TEST_MEM_OFFSET; - void *test_area2_base = guest_test_mem + GUEST_TEST_MEM_SIZE; - uint64_t test_area2_size = (TEST_AREA_SIZE - (GUEST_TEST_MEM_OFFSET + - GUEST_TEST_MEM_SIZE)); - - return (verify_mem_contents(test_area_base, GUEST_TEST_MEM_OFFSET, area_pattern) && - verify_mem_contents(guest_test_mem, GUEST_TEST_MEM_SIZE, guest_pattern) && - verify_mem_contents(test_area2_base, test_area2_size, area_pattern)); -} - -#define GUEST_STARTED 0 -#define GUEST_PRIVATE_MEM_POPULATED 1 -#define GUEST_SHARED_MEM_POPULATED 2 -#define GUEST_PRIVATE_MEM_POPULATED2 3 - -/* - * Run memory conversion tests with explicit conversion: - * Execute KVM hypercall to map/unmap gpa range which will cause userspace exit - * to back/unback private memory. Subsequent accesses by guest to the gpa range - * will not cause exit to userspace. - * - * Test memory conversion scenarios with following steps: - * 1) Access private memory using private access and verify that memory contents - * are not visible to userspace. - * 2) Convert memory to shared using explicit conversions and ensure that - * userspace is able to access the shared regions. - * 3) Convert memory back to private using explicit conversions and ensure that - * userspace is again not able to access converted private regions. - */ -static void guest_conv_test_fn(void) -{ - void *test_area_base = (void *)TEST_AREA_GPA; - void *guest_test_mem = (void *)(TEST_AREA_GPA + GUEST_TEST_MEM_OFFSET); - uint64_t guest_test_size = GUEST_TEST_MEM_SIZE; - - GUEST_SYNC(GUEST_STARTED); - - populate_test_area(test_area_base, TEST_MEM_DATA_PATTERN1); - GUEST_SYNC(GUEST_PRIVATE_MEM_POPULATED); - GUEST_ASSERT(verify_test_area(test_area_base, TEST_MEM_DATA_PATTERN1, - TEST_MEM_DATA_PATTERN1)); - - kvm_hypercall_map_shared((uint64_t)guest_test_mem, guest_test_size); - - populate_guest_test_mem(guest_test_mem, TEST_MEM_DATA_PATTERN2); - - GUEST_SYNC(GUEST_SHARED_MEM_POPULATED); - GUEST_ASSERT(verify_test_area(test_area_base, TEST_MEM_DATA_PATTERN1, - TEST_MEM_DATA_PATTERN5)); - - kvm_hypercall_map_private((uint64_t)guest_test_mem, guest_test_size); - - populate_guest_test_mem(guest_test_mem, TEST_MEM_DATA_PATTERN3); - GUEST_SYNC(GUEST_PRIVATE_MEM_POPULATED2); - - GUEST_ASSERT(verify_test_area(test_area_base, TEST_MEM_DATA_PATTERN1, - TEST_MEM_DATA_PATTERN3)); - GUEST_DONE(); -} - -#define ASSERT_CONV_TEST_EXIT_IO(vcpu, stage) \ - { \ - struct ucall uc; \ - ASSERT_EQ(vcpu->run->exit_reason, KVM_EXIT_IO); \ - ASSERT_EQ(get_ucall(vcpu, &uc), UCALL_SYNC); \ - ASSERT_EQ(uc.args[1], stage); \ - } - -#define ASSERT_GUEST_DONE(vcpu) \ - { \ - struct ucall uc; \ - ASSERT_EQ(vcpu->run->exit_reason, KVM_EXIT_IO); \ - ASSERT_EQ(get_ucall(vcpu, &uc), UCALL_DONE); \ - } - -static void host_conv_test_fn(struct kvm_vm *vm, struct kvm_vcpu *vcpu) -{ - void *test_area_hva = addr_gpa2hva(vm, TEST_AREA_GPA); - void *guest_test_mem_hva = (test_area_hva + GUEST_TEST_MEM_OFFSET); - - vcpu_run_and_handle_mapgpa(vm, vcpu); - ASSERT_CONV_TEST_EXIT_IO(vcpu, GUEST_STARTED); - populate_test_area(test_area_hva, TEST_MEM_DATA_PATTERN4); - VM_STAGE_PROCESSED(GUEST_STARTED); - - vcpu_run_and_handle_mapgpa(vm, vcpu); - ASSERT_CONV_TEST_EXIT_IO(vcpu, GUEST_PRIVATE_MEM_POPULATED); - TEST_ASSERT(verify_test_area(test_area_hva, TEST_MEM_DATA_PATTERN4, - TEST_MEM_DATA_PATTERN4), "failed"); - VM_STAGE_PROCESSED(GUEST_PRIVATE_MEM_POPULATED); - - vcpu_run_and_handle_mapgpa(vm, vcpu); - ASSERT_CONV_TEST_EXIT_IO(vcpu, GUEST_SHARED_MEM_POPULATED); - TEST_ASSERT(verify_test_area(test_area_hva, TEST_MEM_DATA_PATTERN4, - TEST_MEM_DATA_PATTERN2), "failed"); - populate_guest_test_mem(guest_test_mem_hva, TEST_MEM_DATA_PATTERN5); - VM_STAGE_PROCESSED(GUEST_SHARED_MEM_POPULATED); - - vcpu_run_and_handle_mapgpa(vm, vcpu); - ASSERT_CONV_TEST_EXIT_IO(vcpu, GUEST_PRIVATE_MEM_POPULATED2); - TEST_ASSERT(verify_test_area(test_area_hva, TEST_MEM_DATA_PATTERN4, - TEST_MEM_DATA_PATTERN5), "failed"); - VM_STAGE_PROCESSED(GUEST_PRIVATE_MEM_POPULATED2); - - vcpu_run_and_handle_mapgpa(vm, vcpu); - ASSERT_GUEST_DONE(vcpu); -} - -static void execute_vm_with_private_test_mem( - enum vm_mem_backing_src_type test_mem_src) -{ - struct kvm_vm *vm; - struct kvm_enable_cap cap; - struct kvm_vcpu *vcpu; - - vm = vm_create_with_one_vcpu(&vcpu, guest_conv_test_fn); - - vm_check_cap(vm, KVM_CAP_EXIT_HYPERCALL); - cap.cap = KVM_CAP_EXIT_HYPERCALL; - cap.flags = 0; - cap.args[0] = (1 << KVM_HC_MAP_GPA_RANGE); - vm_ioctl(vm, KVM_ENABLE_CAP, &cap); - - vm_userspace_mem_region_add(vm, test_mem_src, TEST_AREA_GPA, - TEST_AREA_SLOT, TEST_AREA_SIZE / vm->page_size, KVM_MEM_PRIVATE); - vm_allocate_private_mem(vm, TEST_AREA_GPA, TEST_AREA_SIZE); - - virt_map(vm, TEST_AREA_GPA, TEST_AREA_GPA, TEST_AREA_SIZE/vm->page_size); - - host_conv_test_fn(vm, vcpu); - - kvm_vm_free(vm); -} +#include int main(int argc, char *argv[]) { From patchwork Fri Dec 23 00:13:51 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Vishal Annapurve X-Patchwork-Id: 36025 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:adf:e747:0:0:0:0:0 with SMTP id c7csp56790wrn; Thu, 22 Dec 2022 16:18:07 -0800 (PST) X-Google-Smtp-Source: AMrXdXsOy6h0M7b1b3AVBPAL1PawgXfjWds4387u94tgmuW+NntIWvRm6aNT0kr8KauAJ5Q+oQ8/ X-Received: by 2002:a17:903:28d:b0:191:386:d8f with SMTP id j13-20020a170903028d00b0019103860d8fmr8061419plr.47.1671754687427; Thu, 22 Dec 2022 16:18:07 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1671754687; cv=none; d=google.com; s=arc-20160816; b=HyRY8WB9NHwzUCTeta7AEldGwfgFIkC73RoV4mlajZNB44xZEGkNqZap8AUSN3J3vi zvX58qXJ8OPcuyvaTfm0aKLH+pU1D+hNF+AquD+cNHS58sBpmSDf06+mjidiV2BK5wev tt3yVu55x7h4fKgJUzcr4oNY7RIA9vwUQLw5+UkRsWg0ez5pI2Vc01P+PM9c6tbcqLbf kIF2AewsQNCf4gWNv4v+qhdTZFwIHVE6wKyyUyyQoOrcprOfWBEnGshSAtCNj27r429w oy9BEsx1BdWOppwyA0wMj2UloL5OSVoMiu31Q8bomMjrS6DgyJx1fSyh2W0ZFIkskJDw bJ0g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:dkim-signature; bh=Cg/JgGzimgcKVfqgQO+cUvnCvql5iWRhml8JYXpDmXI=; b=IuLFnpzNaPfqLWXCOk7qu2LIkiEvJcn4m3CSwq600MYtps28owVbDCsl+aQB3FDYMG RPEMDtNVV1a97B0rkJ9wsS8UzBnZyRH7R1IT/Fw8QLnepeydr1MjXey+no/xq6hIJ86t HvYENNgT3U8GHgr55pnwJZEqg10ICpOP0RImfy45iwS0MMqsvoEinB0CJgTMlggJqGn0 jQxQXz65c5t2lBqgLq2JCxlQAH17MPQ2bYNGcNLZ68z/xc9nTgtXGZu0qwYe9lWmkBKn DE/BxFXkJqvYvyOi9ldhR75/GLlS+Bl539lhP3C641ZqCalW3sUkZ9+Rahacsp2p+zwl plIw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=sKa9lZOu; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id k3-20020a170902d58300b00189850a8ad8si1811742plh.577.2022.12.22.16.17.38; Thu, 22 Dec 2022 16:18:07 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=sKa9lZOu; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235767AbiLWAOv (ORCPT + 99 others); Thu, 22 Dec 2022 19:14:51 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:45352 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235540AbiLWAO3 (ORCPT ); Thu, 22 Dec 2022 19:14:29 -0500 Received: from mail-yb1-xb4a.google.com (mail-yb1-xb4a.google.com [IPv6:2607:f8b0:4864:20::b4a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B81D02CC9B for ; Thu, 22 Dec 2022 16:14:12 -0800 (PST) Received: by mail-yb1-xb4a.google.com with SMTP id t186-20020a2546c3000000b0071e2aff109dso3559935yba.16 for ; Thu, 22 Dec 2022 16:14:12 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=Cg/JgGzimgcKVfqgQO+cUvnCvql5iWRhml8JYXpDmXI=; b=sKa9lZOuyXiASyHL4kp9hKmVWR3zOuZrETb1wLibzqRJxzfzbNiXmD3S/Ng64NhoIV dG0JMir7Cp6iNktQKkX5sBYxyju/rlNqCnClo9LzUHp/AWgs2Rqw4X/ISUkosL7Vk3hF vOtpWhHppffPQzTZWm8ePcCZB4Mg0y1R3GLScM3UVXHIb1oriQz3rC37vJh6KSbT9dk9 QwVio4xoJMLgsmYL9wa/th4KU9kK7Ifj82VKjZ6iiKgfpicNUasXw2+pT10Imdo1LYz6 RsxZ4cYzbTWlVUGCpcI+kuwa0buaX4maiwjQf007tXO124EPcBnjuFRyKclaij46vGZJ GmGg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=Cg/JgGzimgcKVfqgQO+cUvnCvql5iWRhml8JYXpDmXI=; b=ACR+Htz49kfCi7zNNPjkn3N+zjKVah/YCjhTSrh5T7VyyUlZyZnanGT7VhfiDvyb6A Rbtt+/rqnVbQdBRUq7H10ehFTcYHWg72VZo7/nQD/oJbBOCAKrHqVp8MGL4hcYZN8z5e cXhtsOEvo/1gmdXKoHZociMPsjopmans7NSHh7MA79P2od8WkpWGrom3Wif1+4SqnEmO kDoqnKfNWuM0QbdZA1Z6P8ppK9bqdQUy2lldrh+MFDKX6BUfOUi/zCOcR9yzyhtnz/rI T+87uUmOHR9DEhfIM2h9gEqrGk9nxcClo3sr0W2Qxd7y0yg4NCbouweC5G4aCklbQSTb kI0Q== X-Gm-Message-State: AFqh2ko1ah3XN9nKIbARfhceXbNyOEoSXv4obU09yRA52tECLyhc5rUf 8aBhiDAX+2s3AXZD7SVkVrZhZ6uWqWhWUFTb X-Received: from vannapurve2.c.googlers.com ([fda3:e722:ac3:cc00:7f:e700:c0a8:41f8]) (user=vannapurve job=sendgmr) by 2002:a25:4485:0:b0:764:2d1e:4345 with SMTP id r127-20020a254485000000b007642d1e4345mr404750yba.551.1671754451977; Thu, 22 Dec 2022 16:14:11 -0800 (PST) Date: Fri, 23 Dec 2022 00:13:51 +0000 In-Reply-To: <20221223001352.3873203-1-vannapurve@google.com> Mime-Version: 1.0 References: <20221223001352.3873203-1-vannapurve@google.com> X-Mailer: git-send-email 2.39.0.314.g84b9a713c41-goog Message-ID: <20221223001352.3873203-8-vannapurve@google.com> Subject: [V3 PATCH 7/8] KVM: selftests: private_mem_test: Add support for SEV VMs From: Vishal Annapurve To: x86@kernel.org, kvm@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org Cc: pbonzini@redhat.com, vkuznets@redhat.com, wanpengli@tencent.com, jmattson@google.com, joro@8bytes.org, tglx@linutronix.de, mingo@redhat.com, bp@alien8.de, dave.hansen@linux.intel.com, hpa@zytor.com, shuah@kernel.org, yang.zhong@intel.com, drjones@redhat.com, ricarkol@google.com, aaronlewis@google.com, wei.w.wang@intel.com, kirill.shutemov@linux.intel.com, corbet@lwn.net, hughd@google.com, jlayton@kernel.org, bfields@fieldses.org, akpm@linux-foundation.org, chao.p.peng@linux.intel.com, yu.c.zhang@linux.intel.com, jun.nakajima@intel.com, dave.hansen@intel.com, michael.roth@amd.com, qperret@google.com, steven.price@arm.com, ak@linux.intel.com, david@redhat.com, luto@kernel.org, vbabka@suse.cz, marcorr@google.com, erdemaktas@google.com, pgonda@google.com, nikunj@amd.com, seanjc@google.com, diviness@google.com, maz@kernel.org, dmatlack@google.com, axelrasmussen@google.com, maciej.szmigiero@oracle.com, mizhang@google.com, bgardon@google.com, ackerleytng@google.com, Vishal Annapurve X-Spam-Status: No, score=-9.6 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_NONE, SPF_HELO_NONE,SPF_PASS,USER_IN_DEF_DKIM_WL autolearn=unavailable autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1752961843089858513?= X-GMAIL-MSGID: =?utf-8?q?1752961843089858513?= Add support of executing private mem test with SEV VMs to allow creating SEV VMs and make the guest code do page table updates in case of executiong from SEV VM context. Signed-off-by: Vishal Annapurve --- .../include/x86_64/private_mem_test_helper.h | 3 ++ .../kvm/lib/x86_64/private_mem_test_helper.c | 37 +++++++++++++++++-- 2 files changed, 37 insertions(+), 3 deletions(-) diff --git a/tools/testing/selftests/kvm/include/x86_64/private_mem_test_helper.h b/tools/testing/selftests/kvm/include/x86_64/private_mem_test_helper.h index 4d32c025876c..e54870b72369 100644 --- a/tools/testing/selftests/kvm/include/x86_64/private_mem_test_helper.h +++ b/tools/testing/selftests/kvm/include/x86_64/private_mem_test_helper.h @@ -12,4 +12,7 @@ void execute_vm_with_private_test_mem( enum vm_mem_backing_src_type test_mem_src); +void execute_sev_vm_with_private_test_mem( + enum vm_mem_backing_src_type test_mem_src); + #endif /* SELFTEST_KVM_PRIVATE_MEM_TEST_HELPER_H */ diff --git a/tools/testing/selftests/kvm/lib/x86_64/private_mem_test_helper.c b/tools/testing/selftests/kvm/lib/x86_64/private_mem_test_helper.c index 600bd21d1bb8..36a8b1ab1c74 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/private_mem_test_helper.c +++ b/tools/testing/selftests/kvm/lib/x86_64/private_mem_test_helper.c @@ -22,6 +22,9 @@ #include #include #include +#include + +static bool is_guest_sev_vm; #define TEST_AREA_SLOT 10 #define TEST_AREA_GPA 0xC0000000 @@ -104,6 +107,8 @@ static void guest_conv_test_fn(void) GUEST_ASSERT(verify_test_area(test_area_base, TEST_MEM_DATA_PATTERN1, TEST_MEM_DATA_PATTERN1)); + if (is_guest_sev_vm) + guest_set_region_shared(guest_test_mem, guest_test_size); kvm_hypercall_map_shared((uint64_t)guest_test_mem, guest_test_size); populate_guest_test_mem(guest_test_mem, TEST_MEM_DATA_PATTERN2); @@ -112,6 +117,9 @@ static void guest_conv_test_fn(void) GUEST_ASSERT(verify_test_area(test_area_base, TEST_MEM_DATA_PATTERN1, TEST_MEM_DATA_PATTERN5)); + if (is_guest_sev_vm) + guest_set_region_private(guest_test_mem, guest_test_size); + kvm_hypercall_map_private((uint64_t)guest_test_mem, guest_test_size); populate_guest_test_mem(guest_test_mem, TEST_MEM_DATA_PATTERN3); @@ -170,14 +178,19 @@ static void host_conv_test_fn(struct kvm_vm *vm, struct kvm_vcpu *vcpu) ASSERT_GUEST_DONE(vcpu); } -void execute_vm_with_private_test_mem( - enum vm_mem_backing_src_type test_mem_src) +static void execute_private_mem_test(enum vm_mem_backing_src_type test_mem_src, + bool is_sev_vm) { struct kvm_vm *vm; struct kvm_enable_cap cap; struct kvm_vcpu *vcpu; - vm = vm_create_with_one_vcpu(&vcpu, guest_conv_test_fn); + if (is_sev_vm) + vm = sev_vm_init_with_one_vcpu(SEV_POLICY_NO_DBG, + guest_conv_test_fn, &vcpu); + else + vm = vm_create_with_one_vcpu(&vcpu, guest_conv_test_fn); + TEST_ASSERT(vm, "VM creation failed\n"); vm_check_cap(vm, KVM_CAP_EXIT_HYPERCALL); cap.cap = KVM_CAP_EXIT_HYPERCALL; @@ -191,7 +204,25 @@ void execute_vm_with_private_test_mem( virt_map(vm, TEST_AREA_GPA, TEST_AREA_GPA, TEST_AREA_SIZE/vm->page_size); + if (is_sev_vm) { + is_guest_sev_vm = true; + sync_global_to_guest(vm, is_guest_sev_vm); + sev_vm_finalize(vm, SEV_POLICY_NO_DBG); + } + host_conv_test_fn(vm, vcpu); kvm_vm_free(vm); } + +void execute_vm_with_private_test_mem( + enum vm_mem_backing_src_type test_mem_src) +{ + execute_private_mem_test(test_mem_src, false); +} + +void execute_sev_vm_with_private_test_mem( + enum vm_mem_backing_src_type test_mem_src) +{ + execute_private_mem_test(test_mem_src, true); +} From patchwork Fri Dec 23 00:13:52 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Vishal Annapurve X-Patchwork-Id: 36026 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:adf:e747:0:0:0:0:0 with SMTP id c7csp56814wrn; Thu, 22 Dec 2022 16:18:10 -0800 (PST) X-Google-Smtp-Source: AMrXdXuzE6PLDBdOFmHBgCxTEWQbfV6l9SJ23xvMkeMccdWGSgjc0+7AvhWgYHch8aAlg3Xpx9w2 X-Received: by 2002:a17:90b:3597:b0:221:6db6:651e with SMTP id mm23-20020a17090b359700b002216db6651emr8281663pjb.31.1671754689861; Thu, 22 Dec 2022 16:18:09 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1671754689; cv=none; d=google.com; s=arc-20160816; b=VX5GBSDKDO6Q2Na4U5b40tE6DvJMyIHBevDUlB1uz3LYMACcrRPHpzRt3pngz8MFtD Qp+BP1LXyfwc/uENDSHgXvhmzOn/3Ix7scycEAggh+AXGtFSfRMnS5XkVBUXEVlDpJEh bwQWWJmQQEMW7MQ4YhQ4FSh58GnHhTw/h16FwahxnbWLiRMTM9f68WFVOUHVpjiJ/3sq x5IRXq1qQCJw5Gp4BDEbM497wEGD5pR8eP7UzpKqTNmp5Y78O97T7/rkMoUzAHlORuW7 iWVc6avoCc9pegegLtbjKI3QCg1Y/+M0G2AkHgvf96MJLY3XD+G5I8xt4MPiw3TQJ4Va 7vyg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:dkim-signature; bh=mXjvTaFGl0oQkWFtQLkmlcU0BiyCn63t9cGXi+l6V/w=; b=mrXZQHHOdZuRLPyMG6lgR/E0WLu8quopdr65doEKNDucQBFtsjgKam6wQyyFSaAI6b pKQd/bpRU906OkPjBlUyk0HiOimRG3xHM0WF2i2gyVAHuNUvrI7Beo1us3V1uW8DtePQ p4iaRFvK6eBg1ZFzQRG3EMuUmAYdFF7C8/oX4rzS8+8TPL2IODgE7Nj3Akd08cLK6UYI i9UAFhHH8wgfWyvHopaIE7uwfRAMKa0K75Zoxd0ZCc8RhhFAq7gwo8hVn16p0apE1O7l dyI/EQr7IZISJ3M6hamzlXFbWEBv9LPs5zWObmlANEVkUX+BR2sDYjT/LZy8Jn8DsIK1 HJxw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=acLkEOZ4; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id om14-20020a17090b3a8e00b00219c691992esi2110560pjb.131.2022.12.22.16.17.56; Thu, 22 Dec 2022 16:18:09 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=acLkEOZ4; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235915AbiLWAPB (ORCPT + 99 others); Thu, 22 Dec 2022 19:15:01 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:45488 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235798AbiLWAOf (ORCPT ); Thu, 22 Dec 2022 19:14:35 -0500 Received: from mail-pg1-x549.google.com (mail-pg1-x549.google.com [IPv6:2607:f8b0:4864:20::549]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C19592EFB6 for ; Thu, 22 Dec 2022 16:14:14 -0800 (PST) Received: by mail-pg1-x549.google.com with SMTP id 38-20020a630b26000000b004773803dda1so1842711pgl.17 for ; Thu, 22 Dec 2022 16:14:14 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=mXjvTaFGl0oQkWFtQLkmlcU0BiyCn63t9cGXi+l6V/w=; b=acLkEOZ4nvyQu2uxwn2hL7G9VDeqPcNGplhMBS2a+Yx+2SNZIeWbRIHKUjv160NG0L m4d1KpHGQ2RR4P8vLlHgq6jgo7zEUuXsmdGzHVhSiFQvET6Dn4GkihmCSrLavj+zpSes 8CGusZoJ/ApV1KTPj7x4yLhN9l2mKIEZY9i00cpn307Av1luAJreVNajomg2aj1GLaH5 BjUxMIfDWuKDDZfHZN4igce+Jgfx/dOsevMY+0KgQPEcSG5w3V7gSDyz9iQ8s6oGsVO6 51pr/aXD8Jb0W+dVj27LxZ94KU0+dCZsk08OInfH1quXH3A4uj+O+BM3KnT33TzIPjoq dv1Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=mXjvTaFGl0oQkWFtQLkmlcU0BiyCn63t9cGXi+l6V/w=; b=d7Vk4zO3t3I40XfFDTn4wMyx0+sYZfS7sVI5/q9EqUqy3drDzAn82iOgp2nJdt9Goi PNDxS0ViojoxtR/M1XcMLwQxMKtqfDxv5oZpKUWiAYZ7gC/b03TGVbdHQ4SXxa1HcpYo o9g1jwOOCJymNOA7FLhdAak07tTCEaaMZbVw5RBHt9CUI/XiOlnGerqsEJZ3Kuk+0fEj HJjn3b/BPb9pECiiYOebLkipheZceoP+AguOzeqOM8D0dZg/yKW8PKNqY/fOEoD1fsXk BEgu2JGCqeqVal3tIlDDMRM/kjarGiMUtlvYqtfsXLflnAcWEzX4KfvFgSMzTREMugpN keSQ== X-Gm-Message-State: AFqh2koBjYPyL82fBQ1auJirOpz3pna/ESUZXiJ5Sd9DYifzKLSJOJzl Amvr79mXT0l7GyeMNNyBLEDCivo8TQa/4zm3 X-Received: from vannapurve2.c.googlers.com ([fda3:e722:ac3:cc00:7f:e700:c0a8:41f8]) (user=vannapurve job=sendgmr) by 2002:a63:530a:0:b0:46f:1e8d:d6a8 with SMTP id h10-20020a63530a000000b0046f1e8dd6a8mr592287pgb.248.1671754454109; Thu, 22 Dec 2022 16:14:14 -0800 (PST) Date: Fri, 23 Dec 2022 00:13:52 +0000 In-Reply-To: <20221223001352.3873203-1-vannapurve@google.com> Mime-Version: 1.0 References: <20221223001352.3873203-1-vannapurve@google.com> X-Mailer: git-send-email 2.39.0.314.g84b9a713c41-goog Message-ID: <20221223001352.3873203-9-vannapurve@google.com> Subject: [V3 PATCH 8/8] KVM: selftests: Add private mem test for SEV VMs From: Vishal Annapurve To: x86@kernel.org, kvm@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org Cc: pbonzini@redhat.com, vkuznets@redhat.com, wanpengli@tencent.com, jmattson@google.com, joro@8bytes.org, tglx@linutronix.de, mingo@redhat.com, bp@alien8.de, dave.hansen@linux.intel.com, hpa@zytor.com, shuah@kernel.org, yang.zhong@intel.com, drjones@redhat.com, ricarkol@google.com, aaronlewis@google.com, wei.w.wang@intel.com, kirill.shutemov@linux.intel.com, corbet@lwn.net, hughd@google.com, jlayton@kernel.org, bfields@fieldses.org, akpm@linux-foundation.org, chao.p.peng@linux.intel.com, yu.c.zhang@linux.intel.com, jun.nakajima@intel.com, dave.hansen@intel.com, michael.roth@amd.com, qperret@google.com, steven.price@arm.com, ak@linux.intel.com, david@redhat.com, luto@kernel.org, vbabka@suse.cz, marcorr@google.com, erdemaktas@google.com, pgonda@google.com, nikunj@amd.com, seanjc@google.com, diviness@google.com, maz@kernel.org, dmatlack@google.com, axelrasmussen@google.com, maciej.szmigiero@oracle.com, mizhang@google.com, bgardon@google.com, ackerleytng@google.com, Vishal Annapurve X-Spam-Status: No, score=-9.6 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_NONE, SPF_HELO_NONE,SPF_PASS,USER_IN_DEF_DKIM_WL autolearn=unavailable autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1752961845778284109?= X-GMAIL-MSGID: =?utf-8?q?1752961845778284109?= Add SEV VM specific private mem test to invoke selftest logic similar to the one executed for non-confidential VMs. Signed-off-by: Vishal Annapurve --- tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 1 + .../kvm/x86_64/sev_private_mem_test.c | 26 +++++++++++++++++++ 3 files changed, 28 insertions(+) create mode 100644 tools/testing/selftests/kvm/x86_64/sev_private_mem_test.c diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore index f73639dcbebb..e5c82a1cd733 100644 --- a/tools/testing/selftests/kvm/.gitignore +++ b/tools/testing/selftests/kvm/.gitignore @@ -40,6 +40,7 @@ /x86_64/set_sregs_test /x86_64/sev_all_boot_test /x86_64/sev_migrate_tests +/x86_64/sev_private_mem_test /x86_64/smaller_maxphyaddr_emulation_test /x86_64/smm_test /x86_64/state_test diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile index 83c649c9de23..a8ee7c473644 100644 --- a/tools/testing/selftests/kvm/Makefile +++ b/tools/testing/selftests/kvm/Makefile @@ -104,6 +104,7 @@ TEST_GEN_PROGS_x86_64 += x86_64/pmu_event_filter_test TEST_GEN_PROGS_x86_64 += x86_64/private_mem_test TEST_GEN_PROGS_x86_64 += x86_64/set_boot_cpu_id TEST_GEN_PROGS_x86_64 += x86_64/set_sregs_test +TEST_GEN_PROGS_x86_64 += x86_64/sev_private_mem_test TEST_GEN_PROGS_x86_64 += x86_64/smaller_maxphyaddr_emulation_test TEST_GEN_PROGS_x86_64 += x86_64/smm_test TEST_GEN_PROGS_x86_64 += x86_64/state_test diff --git a/tools/testing/selftests/kvm/x86_64/sev_private_mem_test.c b/tools/testing/selftests/kvm/x86_64/sev_private_mem_test.c new file mode 100644 index 000000000000..943fdfbe41d9 --- /dev/null +++ b/tools/testing/selftests/kvm/x86_64/sev_private_mem_test.c @@ -0,0 +1,26 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2022, Google LLC. + */ +#define _GNU_SOURCE /* for program_invocation_short_name */ +#include +#include +#include + +#include + +int main(int argc, char *argv[]) +{ + execute_sev_vm_with_private_test_mem( + VM_MEM_SRC_ANONYMOUS_AND_RESTRICTED_MEMFD); + + /* Needs 2MB Hugepages */ + if (get_free_huge_2mb_pages() >= 1) { + printf("Running SEV VM private mem test with 2M pages\n"); + execute_sev_vm_with_private_test_mem( + VM_MEM_SRC_ANON_HTLB2M_AND_RESTRICTED_MEMFD); + } else + printf("Skipping SEV VM private mem test with 2M pages\n"); + + return 0; +}