From nobody Mon May 11 07:46:23 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 197AFC433EF for ; Mon, 11 Apr 2022 21:10:48 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1350033AbiDKVNA (ORCPT ); Mon, 11 Apr 2022 17:13:00 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37936 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1348118AbiDKVMy (ORCPT ); Mon, 11 Apr 2022 17:12:54 -0400 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 B96CF193C0 for ; Mon, 11 Apr 2022 14:10:38 -0700 (PDT) Received: by mail-pf1-x44a.google.com with SMTP id y7-20020a62ce07000000b005058f370a08so4975108pfg.6 for ; Mon, 11 Apr 2022 14:10:38 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=kJgMoCAjhZF08CgV3+jJ2ov9zdWBjUSyLPZfA15qjOk=; b=B1yK7n6ZfFUfK1bizsnRSAreeQmV+uitxPCS7NJyd6tleGrqGPsczFz4fmJWbnJT8i c9J395P0abuq+kKprK3PO0O6A7vhMQsPNcD9akSwJaJUMktxk/LN44khMc1bwMeJ4ZZI j6waqiifNBYXRR5UpjRk/nff2Az0lr4T/eqOoidoYzmnbpswmssa8p4FIWLmOo0LeUfi RwTMlnheEI30n2vRphdKBlzjdoK47/lwN1D5JLPCfXbw57klYnTkZ9EA7bKvNTo5a61u JaUSJEW9zldw4y+QNyCpt9cqiL0r97EmYULHjPeNkAWpVMlrwLkV9EVwDHRQuFvaBPMv jDdw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=kJgMoCAjhZF08CgV3+jJ2ov9zdWBjUSyLPZfA15qjOk=; b=d3cfdROFBpRZ16s1mWFW2KrkiUCKRXXQJswSuxEzV+BK+H6O53Hy9cebmbMXo3MP3x 63wH6zADHBpsafBfqSxs9MUHV4RKrrm7C6xfQnwfS6TOj+RNGawzyfS4TLv6O6+MCruA 8OnBFPTdlEAfQtbnJb2gRYtlsrGTsdWK/GaDWu0YDBOHrd9XO2l4b6tLmrlx848TOjv3 eqAEzAcgX+vWkcH/MbUxK0ABqKQ03QNJY0/SN6Oy9R6urUytg8x7ShO/8SptuOguWHGi PdeJqzM6G+/sdRRGxU/bAs0I6Ejn7m4+II7kVesB1uF0+TDhUPEhZGepxXI3jsHufB6l YlcA== X-Gm-Message-State: AOAM531MCxXvLOva3bOvfdyOql0XcsWIpRSHZivX4EDARJi7xqgXswGe +fRFVZjUQdT+R6jrqxUtc+0dB5p7vTuoqutkKMz5PGIEIHNuln3B0SqUAZkmEyMb/rnpz0N/ecL KDQAlwRViespoC8vbG63w/5jDhtj4hBE/eb/TdYzZGGOyAo6XAHRmhCZfeO5vV2oWjg6HraNi X-Google-Smtp-Source: ABdhPJxRz84knoKx1GpcAy3ttUlScLwKOziY1SrT418kLk5rHFDxHG/9t9dbma3H8fJL3QXGxEkPuoDVYIsO X-Received: from bgardon.sea.corp.google.com ([2620:15c:100:202:a2d0:faec:7d8b:2e0b]) (user=bgardon job=sendgmr) by 2002:a17:903:1251:b0:156:9d8e:1077 with SMTP id u17-20020a170903125100b001569d8e1077mr33659510plh.116.1649711438004; Mon, 11 Apr 2022 14:10:38 -0700 (PDT) Date: Mon, 11 Apr 2022 14:10:06 -0700 In-Reply-To: <20220411211015.3091615-1-bgardon@google.com> Message-Id: <20220411211015.3091615-2-bgardon@google.com> Mime-Version: 1.0 References: <20220411211015.3091615-1-bgardon@google.com> X-Mailer: git-send-email 2.35.1.1178.g4f1659d476-goog Subject: [PATCH v4 01/10] KVM: selftests: Remove dynamic memory allocation for stats header From: Ben Gardon To: linux-kernel@vger.kernel.org, kvm@vger.kernel.org Cc: Paolo Bonzini , Peter Xu , Sean Christopherson , Peter Shier , David Dunn , Junaid Shahid , Jim Mattson , David Matlack , Mingwei Zhang , Jing Zhang , Ben Gardon Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" There's no need to allocate dynamic memory for the stats header since its size is known at compile time. Signed-off-by: Ben Gardon Reviewed-by: David Matlack Reviewed-by: Mingwei Zhang --- .../selftests/kvm/kvm_binary_stats_test.c | 58 +++++++++---------- 1 file changed, 27 insertions(+), 31 deletions(-) diff --git a/tools/testing/selftests/kvm/kvm_binary_stats_test.c b/tools/te= sting/selftests/kvm/kvm_binary_stats_test.c index 17f65d514915..dad34d8a41fe 100644 --- a/tools/testing/selftests/kvm/kvm_binary_stats_test.c +++ b/tools/testing/selftests/kvm/kvm_binary_stats_test.c @@ -26,56 +26,53 @@ static void stats_test(int stats_fd) int i; size_t size_desc; size_t size_data =3D 0; - struct kvm_stats_header *header; + struct kvm_stats_header header; char *id; struct kvm_stats_desc *stats_desc; u64 *stats_data; struct kvm_stats_desc *pdesc; =20 /* Read kvm stats header */ - header =3D malloc(sizeof(*header)); - TEST_ASSERT(header, "Allocate memory for stats header"); - - ret =3D read(stats_fd, header, sizeof(*header)); - TEST_ASSERT(ret =3D=3D sizeof(*header), "Read stats header"); - size_desc =3D sizeof(*stats_desc) + header->name_size; + ret =3D read(stats_fd, &header, sizeof(header)); + TEST_ASSERT(ret =3D=3D sizeof(header), "Read stats header"); + size_desc =3D sizeof(*stats_desc) + header.name_size; =20 /* Read kvm stats id string */ - id =3D malloc(header->name_size); + id =3D malloc(header.name_size); TEST_ASSERT(id, "Allocate memory for id string"); - ret =3D read(stats_fd, id, header->name_size); - TEST_ASSERT(ret =3D=3D header->name_size, "Read id string"); + ret =3D read(stats_fd, id, header.name_size); + TEST_ASSERT(ret =3D=3D header.name_size, "Read id string"); =20 /* Check id string, that should start with "kvm" */ - TEST_ASSERT(!strncmp(id, "kvm", 3) && strlen(id) < header->name_size, + TEST_ASSERT(!strncmp(id, "kvm", 3) && strlen(id) < header.name_size, "Invalid KVM stats type, id: %s", id); =20 /* Sanity check for other fields in header */ - if (header->num_desc =3D=3D 0) { + if (header.num_desc =3D=3D 0) { printf("No KVM stats defined!"); return; } /* Check overlap */ - TEST_ASSERT(header->desc_offset > 0 && header->data_offset > 0 - && header->desc_offset >=3D sizeof(*header) - && header->data_offset >=3D sizeof(*header), + TEST_ASSERT(header.desc_offset > 0 && header.data_offset > 0 + && header.desc_offset >=3D sizeof(header) + && header.data_offset >=3D sizeof(header), "Invalid offset fields in header"); - TEST_ASSERT(header->desc_offset > header->data_offset || - (header->desc_offset + size_desc * header->num_desc <=3D - header->data_offset), + TEST_ASSERT(header.desc_offset > header.data_offset || + (header.desc_offset + size_desc * header.num_desc <=3D + header.data_offset), "Descriptor block is overlapped with data block"); =20 /* Allocate memory for stats descriptors */ - stats_desc =3D calloc(header->num_desc, size_desc); + stats_desc =3D calloc(header.num_desc, size_desc); TEST_ASSERT(stats_desc, "Allocate memory for stats descriptors"); /* Read kvm stats descriptors */ ret =3D pread(stats_fd, stats_desc, - size_desc * header->num_desc, header->desc_offset); - TEST_ASSERT(ret =3D=3D size_desc * header->num_desc, + size_desc * header.num_desc, header.desc_offset); + TEST_ASSERT(ret =3D=3D size_desc * header.num_desc, "Read KVM stats descriptors"); =20 /* Sanity check for fields in descriptors */ - for (i =3D 0; i < header->num_desc; ++i) { + for (i =3D 0; i < header.num_desc; ++i) { pdesc =3D (void *)stats_desc + i * size_desc; /* Check type,unit,base boundaries */ TEST_ASSERT((pdesc->flags & KVM_STATS_TYPE_MASK) @@ -104,7 +101,7 @@ static void stats_test(int stats_fd) break; } /* Check name string */ - TEST_ASSERT(strlen(pdesc->name) < header->name_size, + TEST_ASSERT(strlen(pdesc->name) < header.name_size, "KVM stats name(%s) too long", pdesc->name); /* Check size field, which should not be zero */ TEST_ASSERT(pdesc->size, "KVM descriptor(%s) with size of 0", @@ -124,14 +121,14 @@ static void stats_test(int stats_fd) size_data +=3D pdesc->size * sizeof(*stats_data); } /* Check overlap */ - TEST_ASSERT(header->data_offset >=3D header->desc_offset - || header->data_offset + size_data <=3D header->desc_offset, + TEST_ASSERT(header.data_offset >=3D header.desc_offset + || header.data_offset + size_data <=3D header.desc_offset, "Data block is overlapped with Descriptor block"); /* Check validity of all stats data size */ - TEST_ASSERT(size_data >=3D header->num_desc * sizeof(*stats_data), + TEST_ASSERT(size_data >=3D header.num_desc * sizeof(*stats_data), "Data size is not correct"); /* Check stats offset */ - for (i =3D 0; i < header->num_desc; ++i) { + for (i =3D 0; i < header.num_desc; ++i) { pdesc =3D (void *)stats_desc + i * size_desc; TEST_ASSERT(pdesc->offset < size_data, "Invalid offset (%u) for stats: %s", @@ -142,15 +139,15 @@ static void stats_test(int stats_fd) stats_data =3D malloc(size_data); TEST_ASSERT(stats_data, "Allocate memory for stats data"); /* Read kvm stats data as a bulk */ - ret =3D pread(stats_fd, stats_data, size_data, header->data_offset); + ret =3D pread(stats_fd, stats_data, size_data, header.data_offset); TEST_ASSERT(ret =3D=3D size_data, "Read KVM stats data"); /* Read kvm stats data one by one */ size_data =3D 0; - for (i =3D 0; i < header->num_desc; ++i) { + for (i =3D 0; i < header.num_desc; ++i) { pdesc =3D (void *)stats_desc + i * size_desc; ret =3D pread(stats_fd, stats_data, pdesc->size * sizeof(*stats_data), - header->data_offset + size_data); + header.data_offset + size_data); TEST_ASSERT(ret =3D=3D pdesc->size * sizeof(*stats_data), "Read data of KVM stats: %s", pdesc->name); size_data +=3D pdesc->size * sizeof(*stats_data); @@ -159,7 +156,6 @@ static void stats_test(int stats_fd) free(stats_data); free(stats_desc); free(id); - free(header); } =20 =20 --=20 2.35.1.1178.g4f1659d476-goog From nobody Mon May 11 07:46:23 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3B6F7C433EF for ; Mon, 11 Apr 2022 21:10:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1350047AbiDKVNE (ORCPT ); Mon, 11 Apr 2022 17:13:04 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38050 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1350020AbiDKVMz (ORCPT ); Mon, 11 Apr 2022 17:12:55 -0400 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 763AA19C14 for ; Mon, 11 Apr 2022 14:10:40 -0700 (PDT) Received: by mail-pj1-x104a.google.com with SMTP id rm11-20020a17090b3ecb00b001c713925e58so250460pjb.6 for ; Mon, 11 Apr 2022 14:10:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=6WTud4t2/o0hsvjWQOQfdmuf5Jf6mvrUa1JIGUzDHLI=; b=VHuO5hifqls6sBiOFF5trRISTudPJeSwLA69oUCU92UK7hmXgQ3INRQpOKeXurszhH EDVKKYo5KOuKzaHnVJfH22q6tXxy+3wf3b+YDD40dAt1q2vuG18/51poqqXCto931V/n gP7pZY6UPTcqwOeqUPzi+IQAZne0jzBjhUbZE+qNGzBkT/TuS7m1NMlSZ/ruGj/aWvXQ Fly45ZuxfYEGtm15GgL0luQMUfYss1s3Bao9xsB5D/Wkb9pgR4C++cy6sRx6dlbfZFij AuOL6YT/sCdXkE9G/r3cSEpeSB3fJ3ayZ5QUgjExwRLjnlYd+SlX/ddQ6sktXzv8zTtg EPPg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=6WTud4t2/o0hsvjWQOQfdmuf5Jf6mvrUa1JIGUzDHLI=; b=lV/V+kKFg+bLm1iAvz3Thvgu2QQKlZlk0yT98CsMdd35c12QkJysrzfQL7U5GbW+W9 O++C7iemS/PeRWVweROwMBVhvbpXAYGm0agnSRRBQS6qWPeVCBtwU1Mf8mjQJn70mNse qNYFWyHtDL3CJTjfxO8v11LzL3BxWlbUKPuTciwbTOfb+tggJL0qKcwEUV/HyWi+NtRP RzX/tUA+8GVWFQkiRcG0kkX7tU0cGAjx5z56h273/Xt9WL7mSBF0qX1LKaoM8elIhAyI 7MRa8dR1OfMyflFvNyZKa3AI52X/VhBvwg1e7sR8W22hdUMlhV0AHfs7YyruPAMyZszy GWCg== X-Gm-Message-State: AOAM530vQ8+D0/0nDoitcAAqgdDLBuR3WJBKHFF30PvVFefUt8KvjRJI VPFXfdmUGG5N2eYal02T0mM2YpV8MZxjBSLas4w9JEjXPm7dJg6Po0nDQoLRVAIQ4fGIULbiIOf rGl9G5JwQMLxfleEKFRsq3wrVQ6VGulFmEkxxlIdaC+ErTLHKcG6uNEmm8P5ygeBEQYgUMAcm X-Google-Smtp-Source: ABdhPJzijb1tEhtGCiz626QqQz2oBsdS4t++17JOsaPUm80osckqSdyQGNl8CQiPE3Gl+j2KfvnOxc2Gz00D X-Received: from bgardon.sea.corp.google.com ([2620:15c:100:202:a2d0:faec:7d8b:2e0b]) (user=bgardon job=sendgmr) by 2002:a17:903:2488:b0:156:1e8d:a82 with SMTP id p8-20020a170903248800b001561e8d0a82mr34228889plw.51.1649711439874; Mon, 11 Apr 2022 14:10:39 -0700 (PDT) Date: Mon, 11 Apr 2022 14:10:07 -0700 In-Reply-To: <20220411211015.3091615-1-bgardon@google.com> Message-Id: <20220411211015.3091615-3-bgardon@google.com> Mime-Version: 1.0 References: <20220411211015.3091615-1-bgardon@google.com> X-Mailer: git-send-email 2.35.1.1178.g4f1659d476-goog Subject: [PATCH v4 02/10] KVM: selftests: Read binary stats header in lib From: Ben Gardon To: linux-kernel@vger.kernel.org, kvm@vger.kernel.org Cc: Paolo Bonzini , Peter Xu , Sean Christopherson , Peter Shier , David Dunn , Junaid Shahid , Jim Mattson , David Matlack , Mingwei Zhang , Jing Zhang , Ben Gardon Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Move the code to read the binary stats header to the KVM selftests library. It will be re-used by other tests to check KVM behavior. No functional change intended. Signed-off-by: Ben Gardon --- tools/testing/selftests/kvm/include/kvm_util_base.h | 1 + tools/testing/selftests/kvm/kvm_binary_stats_test.c | 4 ++-- tools/testing/selftests/kvm/lib/kvm_util.c | 8 ++++++++ 3 files changed, 11 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/kvm/include/kvm_util_base.h b/tools/te= sting/selftests/kvm/include/kvm_util_base.h index 92cef0ffb19e..5ba3132f3110 100644 --- a/tools/testing/selftests/kvm/include/kvm_util_base.h +++ b/tools/testing/selftests/kvm/include/kvm_util_base.h @@ -400,6 +400,7 @@ void assert_on_unhandled_exception(struct kvm_vm *vm, u= int32_t vcpuid); =20 int vm_get_stats_fd(struct kvm_vm *vm); int vcpu_get_stats_fd(struct kvm_vm *vm, uint32_t vcpuid); +void read_vm_stats_header(int stats_fd, struct kvm_stats_header *header); =20 uint32_t guest_get_vcpuid(void); =20 diff --git a/tools/testing/selftests/kvm/kvm_binary_stats_test.c b/tools/te= sting/selftests/kvm/kvm_binary_stats_test.c index dad34d8a41fe..22c22a90f15a 100644 --- a/tools/testing/selftests/kvm/kvm_binary_stats_test.c +++ b/tools/testing/selftests/kvm/kvm_binary_stats_test.c @@ -33,8 +33,8 @@ static void stats_test(int stats_fd) struct kvm_stats_desc *pdesc; =20 /* Read kvm stats header */ - ret =3D read(stats_fd, &header, sizeof(header)); - TEST_ASSERT(ret =3D=3D sizeof(header), "Read stats header"); + read_vm_stats_header(stats_fd, &header); + size_desc =3D sizeof(*stats_desc) + header.name_size; =20 /* Read kvm stats id string */ diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/sel= ftests/kvm/lib/kvm_util.c index 1665a220abcb..0caf28e324ed 100644 --- a/tools/testing/selftests/kvm/lib/kvm_util.c +++ b/tools/testing/selftests/kvm/lib/kvm_util.c @@ -2556,3 +2556,11 @@ int vcpu_get_stats_fd(struct kvm_vm *vm, uint32_t vc= puid) =20 return ioctl(vcpu->fd, KVM_GET_STATS_FD, NULL); } + +void read_vm_stats_header(int stats_fd, struct kvm_stats_header *header) +{ + ssize_t ret; + + ret =3D read(stats_fd, header, sizeof(*header)); + TEST_ASSERT(ret =3D=3D sizeof(*header), "Read stats header"); +} --=20 2.35.1.1178.g4f1659d476-goog From nobody Mon May 11 07:46:23 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id BA579C433F5 for ; Mon, 11 Apr 2022 21:10:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1350053AbiDKVNH (ORCPT ); Mon, 11 Apr 2022 17:13:07 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38244 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1350031AbiDKVM6 (ORCPT ); Mon, 11 Apr 2022 17:12:58 -0400 Received: from mail-pg1-x54a.google.com (mail-pg1-x54a.google.com [IPv6:2607:f8b0:4864:20::54a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E4F4E19C14 for ; Mon, 11 Apr 2022 14:10:42 -0700 (PDT) Received: by mail-pg1-x54a.google.com with SMTP id q13-20020a638c4d000000b003821725ad66so9429327pgn.23 for ; Mon, 11 Apr 2022 14:10:42 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=jowVcPeazSi67SHgtKHyWBS9ErkTHd94DAj2Ts0QL0M=; b=Fkyh/qBc5dAbHEPYor9iqLZ2edWjPV7qo03ufqQAJHs5D95oaD8g1hbsktBpWjPvd8 Tj9GgivDJotqnPauWNFysO5DvaLksOyFYeq0WEOq9k+BXexF9ZK5YA7j27I9YinVQRuq YYo8VRSpCeYCmwERrYYwq1qXnVf7h47eFGcKneLkLYymrLIVwooPor/E3ApLLjyp0+VC ASaaFV8CVJClt7aQtjPiw7HsMJERACVWfm/BoluRf+O1D0t2GM+vb/IZEgO+SO0K+IgB mFIPumy9JwhOMQtO3nHrUZLgCcirwK7VfF4EWnCjEf6WGiPnNXtTf0jtX1s8uhh3oIL8 X7HQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=jowVcPeazSi67SHgtKHyWBS9ErkTHd94DAj2Ts0QL0M=; b=52JUd7T/MWqxV2t2zJIgRRrhbRdWdiCC20CVBVvBeu/I7281pnNbw15GkfwkTaQymy huH9aS4i1H2NugkQ9VfDljLKSMXXvOUTssg+gJ0/E/ECVEF4rmL5OQGynkQbXUGS9ftm na3WQ2NN0Qh8a2bzKEY30Huh0582hnCLwOw+4LPqdDqjvHM/vIecoks2drgy8vEoGdW5 3+FcZz98q22s6lgxOnBpzkXCd+PHs8Vw+FTvJZ/A/q2snMuTAIAFa6KKccwM7GIPixN/ WwrzRDRn3WE0V4W9ud8/oNFhAIoeS5EppcW31rQgXvJ2ZxweH7hkdS2fwAzzRMhnFQjI 7hPQ== X-Gm-Message-State: AOAM530NcAfvH1UiH7IEgHWH6mgx5ZzZCEdGjpSO3wa6Mo3C6ZntUyr+ D5TJs9lLT+P9JuNGKkYAIOKR2zd3OAWFUemkwP4Vi0kENEPdIRg7iR5xY4mEjhckiH7AJV+DzrZ 68ig47EyBF44kP6RP06pUpailVMrca/DlJs82Dn0BMUSBoSr2naENc2iUx2n7ZIJF20Gk5LWA X-Google-Smtp-Source: ABdhPJw5goVNxXsGn1XxWfE1rh4zn1jaQ5MJFUoJlaymhAL+7IoXVGg0+wZdui9Zaj+6jHwCcufa++gDmrrn X-Received: from bgardon.sea.corp.google.com ([2620:15c:100:202:a2d0:faec:7d8b:2e0b]) (user=bgardon job=sendgmr) by 2002:a17:90b:2384:b0:1cb:5223:9dc4 with SMTP id mr4-20020a17090b238400b001cb52239dc4mr116087pjb.1.1649711441713; Mon, 11 Apr 2022 14:10:41 -0700 (PDT) Date: Mon, 11 Apr 2022 14:10:08 -0700 In-Reply-To: <20220411211015.3091615-1-bgardon@google.com> Message-Id: <20220411211015.3091615-4-bgardon@google.com> Mime-Version: 1.0 References: <20220411211015.3091615-1-bgardon@google.com> X-Mailer: git-send-email 2.35.1.1178.g4f1659d476-goog Subject: [PATCH v4 03/10] KVM: selftests: Read binary stats desc in lib From: Ben Gardon To: linux-kernel@vger.kernel.org, kvm@vger.kernel.org Cc: Paolo Bonzini , Peter Xu , Sean Christopherson , Peter Shier , David Dunn , Junaid Shahid , Jim Mattson , David Matlack , Mingwei Zhang , Jing Zhang , Ben Gardon Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Move the code to read the binary stats descriptors to the KVM selftests library. It will be re-used by other tests to check KVM behavior. No functional change intended. Signed-off-by: Ben Gardon --- .../selftests/kvm/include/kvm_util_base.h | 4 +++ .../selftests/kvm/kvm_binary_stats_test.c | 9 ++---- tools/testing/selftests/kvm/lib/kvm_util.c | 29 +++++++++++++++++++ 3 files changed, 35 insertions(+), 7 deletions(-) diff --git a/tools/testing/selftests/kvm/include/kvm_util_base.h b/tools/te= sting/selftests/kvm/include/kvm_util_base.h index 5ba3132f3110..c5f34551ff76 100644 --- a/tools/testing/selftests/kvm/include/kvm_util_base.h +++ b/tools/testing/selftests/kvm/include/kvm_util_base.h @@ -401,6 +401,10 @@ void assert_on_unhandled_exception(struct kvm_vm *vm, = uint32_t vcpuid); int vm_get_stats_fd(struct kvm_vm *vm); int vcpu_get_stats_fd(struct kvm_vm *vm, uint32_t vcpuid); void read_vm_stats_header(int stats_fd, struct kvm_stats_header *header); +struct kvm_stats_desc *alloc_vm_stats_desc(int stats_fd, + struct kvm_stats_header *header); +void read_vm_stats_desc(int stats_fd, struct kvm_stats_header *header, + struct kvm_stats_desc *stats_desc); =20 uint32_t guest_get_vcpuid(void); =20 diff --git a/tools/testing/selftests/kvm/kvm_binary_stats_test.c b/tools/te= sting/selftests/kvm/kvm_binary_stats_test.c index 22c22a90f15a..e4795bad7db6 100644 --- a/tools/testing/selftests/kvm/kvm_binary_stats_test.c +++ b/tools/testing/selftests/kvm/kvm_binary_stats_test.c @@ -62,14 +62,9 @@ static void stats_test(int stats_fd) header.data_offset), "Descriptor block is overlapped with data block"); =20 - /* Allocate memory for stats descriptors */ - stats_desc =3D calloc(header.num_desc, size_desc); - TEST_ASSERT(stats_desc, "Allocate memory for stats descriptors"); /* Read kvm stats descriptors */ - ret =3D pread(stats_fd, stats_desc, - size_desc * header.num_desc, header.desc_offset); - TEST_ASSERT(ret =3D=3D size_desc * header.num_desc, - "Read KVM stats descriptors"); + stats_desc =3D alloc_vm_stats_desc(stats_fd, &header); + read_vm_stats_desc(stats_fd, &header, stats_desc); =20 /* Sanity check for fields in descriptors */ for (i =3D 0; i < header.num_desc; ++i) { diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/sel= ftests/kvm/lib/kvm_util.c index 0caf28e324ed..e3ae26fbef03 100644 --- a/tools/testing/selftests/kvm/lib/kvm_util.c +++ b/tools/testing/selftests/kvm/lib/kvm_util.c @@ -2564,3 +2564,32 @@ void read_vm_stats_header(int stats_fd, struct kvm_s= tats_header *header) ret =3D read(stats_fd, header, sizeof(*header)); TEST_ASSERT(ret =3D=3D sizeof(*header), "Read stats header"); } + +static ssize_t stats_descs_size(struct kvm_stats_header *header) +{ + return header->num_desc * + (sizeof(struct kvm_stats_desc) + header->name_size); +} + +/* Caller is responsible for freeing the returned kvm_stats_desc. */ +struct kvm_stats_desc *alloc_vm_stats_desc(int stats_fd, + struct kvm_stats_header *header) +{ + struct kvm_stats_desc *stats_desc; + + stats_desc =3D malloc(stats_descs_size(header)); + TEST_ASSERT(stats_desc, "Allocate memory for stats descriptors"); + + return stats_desc; +} + +void read_vm_stats_desc(int stats_fd, struct kvm_stats_header *header, + struct kvm_stats_desc *stats_desc) +{ + ssize_t ret; + + ret =3D pread(stats_fd, stats_desc, stats_descs_size(header), + header->desc_offset); + TEST_ASSERT(ret =3D=3D stats_descs_size(header), + "Read KVM stats descriptors"); +} --=20 2.35.1.1178.g4f1659d476-goog From nobody Mon May 11 07:46:23 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id CAD21C433F5 for ; Mon, 11 Apr 2022 21:10:57 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1350078AbiDKVNK (ORCPT ); Mon, 11 Apr 2022 17:13:10 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38420 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231282AbiDKVM7 (ORCPT ); Mon, 11 Apr 2022 17:12:59 -0400 Received: from mail-pf1-x449.google.com (mail-pf1-x449.google.com [IPv6:2607:f8b0:4864:20::449]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6A16F2A739 for ; Mon, 11 Apr 2022 14:10:44 -0700 (PDT) Received: by mail-pf1-x449.google.com with SMTP id d5-20020a62f805000000b0050566b4f4c0so8076971pfh.11 for ; Mon, 11 Apr 2022 14:10:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=PnhCdKeHHZWArDQ1iucb3AijNBhmwdSe4l8urUqIw/o=; b=kWej4LqMy2wG9GiOMR4EBwr5fY8uQGDDjlYT4c+BSMgcMMr/n4pfu/ZkxaknhQX9mQ HQ9PnUGA/rLimezn+RYxZT1qDXT+Xk8Kp8Oed0uBrJ93Mw0D49MzRmUmWdyqxZU6XKLn dsZWAj2kVr3HmVKSyzSfOFO/1XJ/lZmKhZc1UCo2xD/lLxE+LLVuJR/o/OTQ9fyEHbQ+ fEs4g83jZGh0KXTL0ATE7EgDsqvpqNsUfUGLDi6kAOHDk7wmlsX/pAHOqXIRzF07Oj35 UYhH09I8HwmBQMF1oJ2P5fGGSC5bASUCobdXbkesfpbyqcQXm80AYPTEKydotOIppkiJ T2PA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=PnhCdKeHHZWArDQ1iucb3AijNBhmwdSe4l8urUqIw/o=; b=C/DBcJ4PI5u27yK89JwFFFWfOYOcOgI2/Ri5h5EbcVNcw8rQBMMRGhjOOMAyQno36R 1s+cKQzZAsu/kyNJUwPFKshPdNrjEjve67lM65NXUzD0i7wO9Cm0a6tnWK+WErqTZaZo vv7kuL3yVonoq0jdmaD0jB3yvdsTz1tD27sfzsB96AK2kBIRxb6MYekTi1ad1JR7I/5K pHRenKmwMmPcRMPQVnEXsvJJODNyRP71eSqoFp8kLHeYZROhX9AZpTm49KaS+g6DsPYO m6ax8bkC/7IHD/WnUkRwbyH8rlk73H9lJh0rIKt9gntY6wY3BcIM3SkfubnhQ4YiXu7p 5Miw== X-Gm-Message-State: AOAM530jEziDGB/CSGxYK+SWIL+51zcQCBfxf/1huXbbKYFq0b/oHWYr MqlUtyEOR3MaOSI7H1uD78JD61iQjm/kRLzWLNGp2AY8CHevhX4spS0YIWGhd+KqlO/wzM0L3B/ 2WSTYuviYJ82rjWpdPBMZwATdxEKzHMB55hBrP2D8xEMr4e5ar59yecgBzpC6s0R5ZRV1lh2d X-Google-Smtp-Source: ABdhPJzyY925u/CK4XLi0NlB4Y6g2g9YO6PFKhDKu7ugWNkxp0SyHsGt8vwqyRqoSKM8xEXH8oneEN7MaUsE X-Received: from bgardon.sea.corp.google.com ([2620:15c:100:202:a2d0:faec:7d8b:2e0b]) (user=bgardon job=sendgmr) by 2002:a17:902:70c8:b0:156:509b:68e3 with SMTP id l8-20020a17090270c800b00156509b68e3mr34743852plt.113.1649711443803; Mon, 11 Apr 2022 14:10:43 -0700 (PDT) Date: Mon, 11 Apr 2022 14:10:09 -0700 In-Reply-To: <20220411211015.3091615-1-bgardon@google.com> Message-Id: <20220411211015.3091615-5-bgardon@google.com> Mime-Version: 1.0 References: <20220411211015.3091615-1-bgardon@google.com> X-Mailer: git-send-email 2.35.1.1178.g4f1659d476-goog Subject: [PATCH v4 04/10] KVM: selftests: Read binary stat data in lib From: Ben Gardon To: linux-kernel@vger.kernel.org, kvm@vger.kernel.org Cc: Paolo Bonzini , Peter Xu , Sean Christopherson , Peter Shier , David Dunn , Junaid Shahid , Jim Mattson , David Matlack , Mingwei Zhang , Jing Zhang , Ben Gardon Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Move the code to read the binary stats data to the KVM selftests library. It will be re-used by other tests to check KVM behavior. No functional change intended. Signed-off-by: Ben Gardon Reviewed-by: Mingwei Zhang --- .../selftests/kvm/include/kvm_util_base.h | 3 +++ .../selftests/kvm/kvm_binary_stats_test.c | 20 +++++------------- tools/testing/selftests/kvm/lib/kvm_util.c | 21 +++++++++++++++++++ 3 files changed, 29 insertions(+), 15 deletions(-) diff --git a/tools/testing/selftests/kvm/include/kvm_util_base.h b/tools/te= sting/selftests/kvm/include/kvm_util_base.h index c5f34551ff76..b2684cfc2cb1 100644 --- a/tools/testing/selftests/kvm/include/kvm_util_base.h +++ b/tools/testing/selftests/kvm/include/kvm_util_base.h @@ -405,6 +405,9 @@ struct kvm_stats_desc *alloc_vm_stats_desc(int stats_fd, struct kvm_stats_header *header); void read_vm_stats_desc(int stats_fd, struct kvm_stats_header *header, struct kvm_stats_desc *stats_desc); +int read_stat_data(int stats_fd, struct kvm_stats_header *header, + struct kvm_stats_desc *desc, uint64_t *data, + ssize_t max_elements); =20 uint32_t guest_get_vcpuid(void); =20 diff --git a/tools/testing/selftests/kvm/kvm_binary_stats_test.c b/tools/te= sting/selftests/kvm/kvm_binary_stats_test.c index e4795bad7db6..97b180249ba0 100644 --- a/tools/testing/selftests/kvm/kvm_binary_stats_test.c +++ b/tools/testing/selftests/kvm/kvm_binary_stats_test.c @@ -20,6 +20,8 @@ #include "asm/kvm.h" #include "linux/kvm.h" =20 +#define STAT_MAX_ELEMENTS 1000 + static void stats_test(int stats_fd) { ssize_t ret; @@ -29,7 +31,7 @@ static void stats_test(int stats_fd) struct kvm_stats_header header; char *id; struct kvm_stats_desc *stats_desc; - u64 *stats_data; + u64 stats_data[STAT_MAX_ELEMENTS]; struct kvm_stats_desc *pdesc; =20 /* Read kvm stats header */ @@ -130,25 +132,13 @@ static void stats_test(int stats_fd) pdesc->offset, pdesc->name); } =20 - /* Allocate memory for stats data */ - stats_data =3D malloc(size_data); - TEST_ASSERT(stats_data, "Allocate memory for stats data"); - /* Read kvm stats data as a bulk */ - ret =3D pread(stats_fd, stats_data, size_data, header.data_offset); - TEST_ASSERT(ret =3D=3D size_data, "Read KVM stats data"); /* Read kvm stats data one by one */ - size_data =3D 0; for (i =3D 0; i < header.num_desc; ++i) { pdesc =3D (void *)stats_desc + i * size_desc; - ret =3D pread(stats_fd, stats_data, - pdesc->size * sizeof(*stats_data), - header.data_offset + size_data); - TEST_ASSERT(ret =3D=3D pdesc->size * sizeof(*stats_data), - "Read data of KVM stats: %s", pdesc->name); - size_data +=3D pdesc->size * sizeof(*stats_data); + read_stat_data(stats_fd, &header, pdesc, stats_data, + ARRAY_SIZE(stats_data)); } =20 - free(stats_data); free(stats_desc); free(id); } diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/sel= ftests/kvm/lib/kvm_util.c index e3ae26fbef03..64e2085f1129 100644 --- a/tools/testing/selftests/kvm/lib/kvm_util.c +++ b/tools/testing/selftests/kvm/lib/kvm_util.c @@ -2593,3 +2593,24 @@ void read_vm_stats_desc(int stats_fd, struct kvm_sta= ts_header *header, TEST_ASSERT(ret =3D=3D stats_descs_size(header), "Read KVM stats descriptors"); } + +int read_stat_data(int stats_fd, struct kvm_stats_header *header, + struct kvm_stats_desc *desc, uint64_t *data, + ssize_t max_elements) +{ + ssize_t ret; + + TEST_ASSERT(desc->size <=3D max_elements, + "Max data elements should be at least as large as stat data"); + + ret =3D pread(stats_fd, data, desc->size * sizeof(*data), + header->data_offset + desc->offset); + + /* ret from pread is in bytes. */ + ret =3D ret / sizeof(*data); + + TEST_ASSERT(ret =3D=3D desc->size, + "Read data of KVM stats: %s", desc->name); + + return ret; +} --=20 2.35.1.1178.g4f1659d476-goog From nobody Mon May 11 07:46:23 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6C146C433EF for ; Mon, 11 Apr 2022 21:11:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1350060AbiDKVNN (ORCPT ); Mon, 11 Apr 2022 17:13:13 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38612 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1350042AbiDKVNB (ORCPT ); Mon, 11 Apr 2022 17:13:01 -0400 Received: from mail-pg1-x54a.google.com (mail-pg1-x54a.google.com [IPv6:2607:f8b0:4864:20::54a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 48EE62AC79 for ; Mon, 11 Apr 2022 14:10:46 -0700 (PDT) Received: by mail-pg1-x54a.google.com with SMTP id r11-20020a63440b000000b0038068f34b0cso9485472pga.0 for ; Mon, 11 Apr 2022 14:10:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=aYlpO3UYkAwqMyaI9bGJppa8qvfnaOS91bqZ6ZkHXeY=; b=hLuSzACPO/kznpwt9mGV0klkrntD/6DK7gxP4cnjQvfnVEVuAXeC32X/id5XAmYjys aW/q/Ths/8TCFjD1G0vvymsRN1xFYhtlhARl9j/Ckt+ME9oxTjEIdj/qh5jIryzlnrnh gAoTmMKFb6tnPc/EVjTIgbDgO1Hk26RIhSssE+I2dmOn8f/ObnngLvAwOxne8A/lOF86 Yuv2NxSRiXxzbuxFrncfANxm1I/FMLabsmlfANqfNp1QA55gy1AmgrWxlJl6MQZ3EVL+ RTNEC7Y8c6rsjjAU8NtYb9tNTJPNgKkjb5zcKPD8TmuZiaCpQlvAYC+exvnF/sfeyCNo oBwg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=aYlpO3UYkAwqMyaI9bGJppa8qvfnaOS91bqZ6ZkHXeY=; b=sNMEppSxSPbuSrz6+avGueKzT+mCe0medg0vqlykWVEOUYeBYqL2JoK6sFR2R8Sh1E PU7UOf3YOmtMz0kRhtaXmwGfJEhhr5ugCcxgM03F994X2Df+hyHayP2dYBSbk6js9Bgc qYQ1g6WsENjfps5Tm9PNfSRI+fNYJtzFTtbSilsAGuSS9eXbPFZOdzCJ+exK9WfDRrBU Ep1raNyPTWi0lngnljNmYRa7gZEoV8PVNBzBTNdxZAzGtM3GJOzD4dDJ2Gu9yjwEQ+Tg Tv/E25aW56mnEPpRd+JEs3fr0v/CkH2X+EMHntyapXP0J+/iWq2N82v+25mQoXr9UGRg yCoQ== X-Gm-Message-State: AOAM531dWMXwnkI6WI9lmv67VVmUCmRt6aoLaykmOgZ8I7oXHkOKGwv3 6SmRLTtG5KO2CU8Ip3iiyFM6ZqwuiYkL9lVgUerp261W4n5B/kXbnuBy8kb+av6cGLO2RxKkTlK CZNjmpMI2hL5GOx281oFbP0oXFODHoiZia4DmnFb55ArnRTdgSc1C7k8FbR+5u/HYpwVeQGNQ X-Google-Smtp-Source: ABdhPJwAP4dQmoNOEYjRrqyz1l5KxDJMi14/Y/+uEwvrWrQQyI9TzWEpQ2UPaBEc8XtPQpoQ/ntKReOsDDc0 X-Received: from bgardon.sea.corp.google.com ([2620:15c:100:202:a2d0:faec:7d8b:2e0b]) (user=bgardon job=sendgmr) by 2002:a17:90a:af86:b0:1c7:db8e:8589 with SMTP id w6-20020a17090aaf8600b001c7db8e8589mr1222150pjq.94.1649711445733; Mon, 11 Apr 2022 14:10:45 -0700 (PDT) Date: Mon, 11 Apr 2022 14:10:10 -0700 In-Reply-To: <20220411211015.3091615-1-bgardon@google.com> Message-Id: <20220411211015.3091615-6-bgardon@google.com> Mime-Version: 1.0 References: <20220411211015.3091615-1-bgardon@google.com> X-Mailer: git-send-email 2.35.1.1178.g4f1659d476-goog Subject: [PATCH v4 05/10] KVM: selftests: Add NX huge pages test From: Ben Gardon To: linux-kernel@vger.kernel.org, kvm@vger.kernel.org Cc: Paolo Bonzini , Peter Xu , Sean Christopherson , Peter Shier , David Dunn , Junaid Shahid , Jim Mattson , David Matlack , Mingwei Zhang , Jing Zhang , Ben Gardon Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" There's currently no test coverage of NX hugepages in KVM selftests, so add a basic test to ensure that the feature works as intended. Signed-off-by: Ben Gardon --- tools/testing/selftests/kvm/Makefile | 10 ++ .../selftests/kvm/include/kvm_util_base.h | 1 + tools/testing/selftests/kvm/lib/kvm_util.c | 48 ++++++ .../selftests/kvm/x86_64/nx_huge_pages_test.c | 163 ++++++++++++++++++ .../kvm/x86_64/nx_huge_pages_test.sh | 25 +++ 5 files changed, 247 insertions(+) create mode 100644 tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c create mode 100755 tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.sh diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests= /kvm/Makefile index af582d168621..9bb9bce4df37 100644 --- a/tools/testing/selftests/kvm/Makefile +++ b/tools/testing/selftests/kvm/Makefile @@ -43,6 +43,10 @@ LIBKVM_aarch64 =3D lib/aarch64/processor.c lib/aarch64/u= call.c lib/aarch64/handler LIBKVM_s390x =3D lib/s390x/processor.c lib/s390x/ucall.c lib/s390x/diag318= _test_handler.c LIBKVM_riscv =3D lib/riscv/processor.c lib/riscv/ucall.c =20 +# Non-compiled test targets +TEST_PROGS_x86_64 +=3D x86_64/nx_huge_pages_test.sh + +# Compiled test targets TEST_GEN_PROGS_x86_64 =3D x86_64/cpuid_test TEST_GEN_PROGS_x86_64 +=3D x86_64/cr4_cpuid_sync_test TEST_GEN_PROGS_x86_64 +=3D x86_64/get_msr_index_features @@ -104,6 +108,9 @@ TEST_GEN_PROGS_x86_64 +=3D steal_time TEST_GEN_PROGS_x86_64 +=3D kvm_binary_stats_test TEST_GEN_PROGS_x86_64 +=3D system_counter_offset_test =20 +# Compiled outputs used by test targets +TEST_GEN_PROGS_EXTENDED_x86_64 +=3D x86_64/nx_huge_pages_test + TEST_GEN_PROGS_aarch64 +=3D aarch64/arch_timer TEST_GEN_PROGS_aarch64 +=3D aarch64/debug-exceptions TEST_GEN_PROGS_aarch64 +=3D aarch64/get-reg-list @@ -142,7 +149,9 @@ TEST_GEN_PROGS_riscv +=3D kvm_page_table_test TEST_GEN_PROGS_riscv +=3D set_memory_region_test TEST_GEN_PROGS_riscv +=3D kvm_binary_stats_test =20 +TEST_PROGS +=3D $(TEST_PROGS_$(UNAME_M)) TEST_GEN_PROGS +=3D $(TEST_GEN_PROGS_$(UNAME_M)) +TEST_GEN_PROGS_EXTENDED +=3D $(TEST_GEN_PROGS_EXTENDED_$(UNAME_M)) LIBKVM +=3D $(LIBKVM_$(UNAME_M)) =20 INSTALL_HDR_PATH =3D $(top_srcdir)/usr @@ -193,6 +202,7 @@ $(OUTPUT)/libkvm.a: $(LIBKVM_OBJS) x :=3D $(shell mkdir -p $(sort $(dir $(TEST_GEN_PROGS)))) all: $(STATIC_LIBS) $(TEST_GEN_PROGS): $(STATIC_LIBS) +$(TEST_GEN_PROGS_EXTENDED): $(STATIC_LIBS) =20 cscope: include_paths =3D $(LINUX_TOOL_INCLUDE) $(LINUX_HDR_PATH) include = lib .. cscope: diff --git a/tools/testing/selftests/kvm/include/kvm_util_base.h b/tools/te= sting/selftests/kvm/include/kvm_util_base.h index b2684cfc2cb1..f9c2ac0a5b97 100644 --- a/tools/testing/selftests/kvm/include/kvm_util_base.h +++ b/tools/testing/selftests/kvm/include/kvm_util_base.h @@ -408,6 +408,7 @@ void read_vm_stats_desc(int stats_fd, struct kvm_stats_= header *header, int read_stat_data(int stats_fd, struct kvm_stats_header *header, struct kvm_stats_desc *desc, uint64_t *data, ssize_t max_elements); +uint64_t vm_get_single_stat(struct kvm_vm *vm, const char *stat_name); =20 uint32_t guest_get_vcpuid(void); =20 diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/sel= ftests/kvm/lib/kvm_util.c index 64e2085f1129..833c7e63d62d 100644 --- a/tools/testing/selftests/kvm/lib/kvm_util.c +++ b/tools/testing/selftests/kvm/lib/kvm_util.c @@ -2614,3 +2614,51 @@ int read_stat_data(int stats_fd, struct kvm_stats_he= ader *header, =20 return ret; } + +static int vm_get_stat_data(struct kvm_vm *vm, const char *stat_name, + uint64_t *data, ssize_t max_elements) +{ + struct kvm_stats_desc *stats_desc; + struct kvm_stats_header header; + struct kvm_stats_desc *desc; + size_t size_desc; + int stats_fd; + int ret =3D -EINVAL; + int i; + + stats_fd =3D vm_get_stats_fd(vm); + + read_vm_stats_header(stats_fd, &header); + + stats_desc =3D alloc_vm_stats_desc(stats_fd, &header); + read_vm_stats_desc(stats_fd, &header, stats_desc); + + size_desc =3D sizeof(struct kvm_stats_desc) + header.name_size; + + /* Read kvm stats data one by one */ + for (i =3D 0; i < header.num_desc; ++i) { + desc =3D (void *)stats_desc + (i * size_desc); + + if (strcmp(desc->name, stat_name)) + continue; + + ret =3D read_stat_data(stats_fd, &header, desc, data, + max_elements); + } + + free(stats_desc); + close(stats_fd); + return ret; +} + +uint64_t vm_get_single_stat(struct kvm_vm *vm, const char *stat_name) +{ + uint64_t data; + int ret; + + ret =3D vm_get_stat_data(vm, stat_name, &data, 1); + TEST_ASSERT(ret =3D=3D 1, + "Stat %s expected to have 1 element, but %d returned", + stat_name, ret); + return data; +} diff --git a/tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c b/tool= s/testing/selftests/kvm/x86_64/nx_huge_pages_test.c new file mode 100644 index 000000000000..3f21726b22c7 --- /dev/null +++ b/tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c @@ -0,0 +1,163 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * tools/testing/selftests/kvm/nx_huge_page_test.c + * + * Usage: to be run via nx_huge_page_test.sh, which does the necessary + * environment setup and teardown + * + * Copyright (C) 2022, Google LLC. + */ + +#define _GNU_SOURCE + +#include +#include +#include + +#include +#include "kvm_util.h" + +#define HPAGE_SLOT 10 +#define HPAGE_GVA (23*1024*1024) +#define HPAGE_GPA (10*1024*1024) +#define HPAGE_SLOT_NPAGES (512 * 3) +#define PAGE_SIZE 4096 + +/* + * When writing to guest memory, write the opcode for the `ret` instructio= n so + * that subsequent iteractions can exercise instruction fetch by calling t= he + * memory. + */ +#define RETURN_OPCODE 0xC3 + +void guest_code(void) +{ + uint64_t hpage_1 =3D HPAGE_GVA; + uint64_t hpage_2 =3D hpage_1 + (PAGE_SIZE * 512); + uint64_t hpage_3 =3D hpage_2 + (PAGE_SIZE * 512); + + READ_ONCE(*(uint64_t *)hpage_1); + GUEST_SYNC(1); + + READ_ONCE(*(uint64_t *)hpage_2); + GUEST_SYNC(2); + + ((void (*)(void)) hpage_1)(); + GUEST_SYNC(3); + + ((void (*)(void)) hpage_3)(); + GUEST_SYNC(4); + + READ_ONCE(*(uint64_t *)hpage_1); + GUEST_SYNC(5); + + READ_ONCE(*(uint64_t *)hpage_3); + GUEST_SYNC(6); +} + +static void check_2m_page_count(struct kvm_vm *vm, int expected_pages_2m) +{ + int actual_pages_2m; + + actual_pages_2m =3D vm_get_single_stat(vm, "pages_2m"); + + TEST_ASSERT(actual_pages_2m =3D=3D expected_pages_2m, + "Unexpected 2m page count. Expected %d, got %d", + expected_pages_2m, actual_pages_2m); +} + +static void check_split_count(struct kvm_vm *vm, int expected_splits) +{ + int actual_splits; + + actual_splits =3D vm_get_single_stat(vm, "nx_lpage_splits"); + + TEST_ASSERT(actual_splits =3D=3D expected_splits, + "Unexpected nx lpage split count. Expected %d, got %d", + expected_splits, actual_splits); +} + +int main(int argc, char **argv) +{ + struct kvm_vm *vm; + struct timespec ts; + void *hva; + + vm =3D vm_create_default(0, 0, guest_code); + + vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS_HUGETLB, + HPAGE_GPA, HPAGE_SLOT, + HPAGE_SLOT_NPAGES, 0); + + virt_map(vm, HPAGE_GVA, HPAGE_GPA, HPAGE_SLOT_NPAGES); + + hva =3D addr_gpa2hva(vm, HPAGE_GPA); + memset(hva, RETURN_OPCODE, HPAGE_SLOT_NPAGES * PAGE_SIZE); + + check_2m_page_count(vm, 0); + check_split_count(vm, 0); + + /* + * The guest code will first read from the first hugepage, resulting + * in a huge page mapping being created. + */ + vcpu_run(vm, 0); + check_2m_page_count(vm, 1); + check_split_count(vm, 0); + + /* + * Then the guest code will read from the second hugepage, resulting + * in another huge page mapping being created. + */ + vcpu_run(vm, 0); + check_2m_page_count(vm, 2); + check_split_count(vm, 0); + + /* + * Next, the guest will execute from the first huge page, causing it + * to be remapped at 4k. + */ + vcpu_run(vm, 0); + check_2m_page_count(vm, 1); + check_split_count(vm, 1); + + /* + * Executing from the third huge page (previously unaccessed) will + * cause part to be mapped at 4k. + */ + vcpu_run(vm, 0); + check_2m_page_count(vm, 1); + check_split_count(vm, 2); + + /* Reading from the first huge page again should have no effect. */ + vcpu_run(vm, 0); + check_2m_page_count(vm, 1); + check_split_count(vm, 2); + + /* + * Give recovery thread time to run. The wrapper script sets + * recovery_period_ms to 100, so wait 5x that. + */ + ts.tv_sec =3D 0; + ts.tv_nsec =3D 500000000; + nanosleep(&ts, NULL); + + /* + * Now that the reclaimer has run, all the split pages should be gone. + */ + check_2m_page_count(vm, 1); + check_split_count(vm, 0); + + /* + * The 4k mapping on hpage 3 should have been removed, so check that + * reading from it causes a huge page mapping to be installed. + */ + vcpu_run(vm, 0); + check_2m_page_count(vm, 2); + check_split_count(vm, 0); + + kvm_vm_free(vm); + + return 0; +} + diff --git a/tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.sh b/too= ls/testing/selftests/kvm/x86_64/nx_huge_pages_test.sh new file mode 100755 index 000000000000..19fc95723fcb --- /dev/null +++ b/tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.sh @@ -0,0 +1,25 @@ +#!/bin/bash +# SPDX-License-Identifier: GPL-2.0-only */ + +# tools/testing/selftests/kvm/nx_huge_page_test.sh +# Copyright (C) 2022, Google LLC. + +NX_HUGE_PAGES=3D$(cat /sys/module/kvm/parameters/nx_huge_pages) +NX_HUGE_PAGES_RECOVERY_RATIO=3D$(cat /sys/module/kvm/parameters/nx_huge_pa= ges_recovery_ratio) +NX_HUGE_PAGES_RECOVERY_PERIOD=3D$(cat /sys/module/kvm/parameters/nx_huge_p= ages_recovery_period_ms) +HUGE_PAGES=3D$(cat /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages) + +echo 1 > /sys/module/kvm/parameters/nx_huge_pages +echo 1 > /sys/module/kvm/parameters/nx_huge_pages_recovery_ratio +echo 100 > /sys/module/kvm/parameters/nx_huge_pages_recovery_period_ms +echo 200 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages + +./nx_huge_pages_test +RET=3D$? + +echo $NX_HUGE_PAGES > /sys/module/kvm/parameters/nx_huge_pages +echo $NX_HUGE_PAGES_RECOVERY_RATIO > /sys/module/kvm/parameters/nx_huge_pa= ges_recovery_ratio +echo $NX_HUGE_PAGES_RECOVERY_PERIOD > /sys/module/kvm/parameters/nx_huge_p= ages_recovery_period_ms +echo $HUGE_PAGES > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages + +exit $RET --=20 2.35.1.1178.g4f1659d476-goog From nobody Mon May 11 07:46:23 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id C4BFDC433EF for ; Mon, 11 Apr 2022 21:11:05 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241432AbiDKVNR (ORCPT ); Mon, 11 Apr 2022 17:13:17 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:39134 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1350070AbiDKVNI (ORCPT ); Mon, 11 Apr 2022 17:13:08 -0400 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 7BBDB2AE2E for ; Mon, 11 Apr 2022 14:10:48 -0700 (PDT) Received: by mail-pg1-x549.google.com with SMTP id w3-20020a639343000000b003821fb4a367so9420707pgm.21 for ; Mon, 11 Apr 2022 14:10:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=5tb57VTUj7RznBKumT5V0V4sQN1PJknWB+EFTfgC840=; b=RMCbNHtoYWPcEkJzuzyfXlxy2zAVP1QniIXjlRQ/38Vf2MAk8bUqhhZQQ1rfRgEkN7 iBFVV//DIZhLtJpSOZXjJ463UdO0OZlGKCrMUGuNiBlxc/9oDmHZoJ5AeLpxVtqcsDEZ QpuapmLzielQA8/GeJdvDYqEO3BUf3yi+4PjGRwolGhc8rGoreBldynhMPodiOanCNPK ioUbvaqNl6AceqrQGv17BhinSlaxCrUMttGzCVQuokjdno0ZOX1AwgSon2157QhmzM/b gHOQWXUaE84GKJI2CKpFBaC2wYJfzlWtofn/faxjtVxMZaE2/HA2+ewIr8M+DoGtFrCH ZtBA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=5tb57VTUj7RznBKumT5V0V4sQN1PJknWB+EFTfgC840=; b=3ssV64TXnCnKddDhzlE6qpeAmealm2VpUG202gIA+AHkdVhFRc8pQhLF9ogNOnIpJy KZ2DKBSa5TsUkzI7MRs6pHvkQM6kKw9NQIsnL1czXYCQ7I1pNw/CW04+7jbM+Ev0425n kWDEzGbOuDs42rHljvGL3kJCCF0jnBHNohnOMV63zq6GCKOQrQbn/npbleLf+eGovwjZ 7/eYGgiHCp81qkN1s4dVQwzgkC+w3nF+pKmD+UUmCeRrtdORXg7MyGV070fqfbb5Vh/E SPwjNHWAgMhOzL/TsNnW8Un6WH3cxeBa0IuXOaHktq+R+s2rQdzYxNBM+lWyd+mp9wbC ASMA== X-Gm-Message-State: AOAM5321lT4AfaIyoTLkE3inA+f5tpG589QQ95AtYmq+x2hUGzLIMXb1 qUBRq38jkIrTLsev2sa6MeYb+nwXV8qGGXuJTo652uVBra0VkHpgt+eftKi0oQQFPpoMZxzfmPg dbv+nSxjZ9KC/1qB4VlGcX9m1gepDf0XRteqo0Kbr425QlT/U1LDF8agTCsDwIZHSu41iuzmg X-Google-Smtp-Source: ABdhPJxsL6DdyjLp5LTJtC5jEC9w+gspSh7pE1TloQ0jtcg6QxneuVU1IA0CrHD2zbY1tajWnb1t8UWE1G8x X-Received: from bgardon.sea.corp.google.com ([2620:15c:100:202:a2d0:faec:7d8b:2e0b]) (user=bgardon job=sendgmr) by 2002:a17:902:d5ce:b0:158:48db:9719 with SMTP id g14-20020a170902d5ce00b0015848db9719mr10966080plh.7.1649711447424; Mon, 11 Apr 2022 14:10:47 -0700 (PDT) Date: Mon, 11 Apr 2022 14:10:11 -0700 In-Reply-To: <20220411211015.3091615-1-bgardon@google.com> Message-Id: <20220411211015.3091615-7-bgardon@google.com> Mime-Version: 1.0 References: <20220411211015.3091615-1-bgardon@google.com> X-Mailer: git-send-email 2.35.1.1178.g4f1659d476-goog Subject: [PATCH v4 06/10] KVM: x86/MMU: Factor out updating NX hugepages state for a VM From: Ben Gardon To: linux-kernel@vger.kernel.org, kvm@vger.kernel.org Cc: Paolo Bonzini , Peter Xu , Sean Christopherson , Peter Shier , David Dunn , Junaid Shahid , Jim Mattson , David Matlack , Mingwei Zhang , Jing Zhang , Ben Gardon Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Factor out the code to update the NX hugepages state for an individual VM. This will be expanded in future commits to allow per-VM control of Nx hugepages. No functional change intended. Reviewed-by: David Matlack Signed-off-by: Ben Gardon --- arch/x86/kvm/mmu/mmu.c | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c index 69a30d6d1e2b..caaa610b7878 100644 --- a/arch/x86/kvm/mmu/mmu.c +++ b/arch/x86/kvm/mmu/mmu.c @@ -6144,6 +6144,15 @@ static void __set_nx_huge_pages(bool val) nx_huge_pages =3D itlb_multihit_kvm_mitigation =3D val; } =20 +static void kvm_update_nx_huge_pages(struct kvm *kvm) +{ + mutex_lock(&kvm->slots_lock); + kvm_mmu_zap_all_fast(kvm); + mutex_unlock(&kvm->slots_lock); + + wake_up_process(kvm->arch.nx_lpage_recovery_thread); +} + static int set_nx_huge_pages(const char *val, const struct kernel_param *k= p) { bool old_val =3D nx_huge_pages; @@ -6166,13 +6175,9 @@ static int set_nx_huge_pages(const char *val, const = struct kernel_param *kp) =20 mutex_lock(&kvm_lock); =20 - list_for_each_entry(kvm, &vm_list, vm_list) { - mutex_lock(&kvm->slots_lock); - kvm_mmu_zap_all_fast(kvm); - mutex_unlock(&kvm->slots_lock); + list_for_each_entry(kvm, &vm_list, vm_list) + kvm_update_nx_huge_pages(kvm); =20 - wake_up_process(kvm->arch.nx_lpage_recovery_thread); - } mutex_unlock(&kvm_lock); } =20 --=20 2.35.1.1178.g4f1659d476-goog From nobody Mon May 11 07:46:23 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3A197C433EF for ; Mon, 11 Apr 2022 21:11:09 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231207AbiDKVNU (ORCPT ); Mon, 11 Apr 2022 17:13:20 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:39270 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1350054AbiDKVNI (ORCPT ); Mon, 11 Apr 2022 17:13:08 -0400 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 13DF72B185 for ; Mon, 11 Apr 2022 14:10:50 -0700 (PDT) Received: by mail-pl1-x649.google.com with SMTP id n11-20020a170902d2cb00b00156c1fd01c2so6729407plc.12 for ; Mon, 11 Apr 2022 14:10:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=G74YOGd+KW6PfFvdswhoDzYcIuStPXuwuhYirfhXwiM=; b=EYkBSxlkjezsOn0WSYft+MgmzUxZWXclsjEeb8M/F9g+FhFQUQCNX4yPI8d8FBgRmV pRxUsb4RnLzRHBRa9K054kS4ljLd0ltg4jkjSpodRquXfeW1fovrPRPAB4tlvZfvsIx/ t5NgnCB2ihQ2YSphonkw7EGj3j9juXOLQVBuyX5D9fFEaCQQrigWOQRamSSAg/tfQ+eq RwTIHCCFQDWG5J3Ik0hRJ0BxQ05f1IdoxltA0imoc/HUFgxqxairkXSOYoJBU42hTPfC rpHCTFgLIGceYiqQncQjCJX9vcgtaOuzqrIhLe7EkE7Ulroo+PZg1foCPQBl3+RgRLyy iDCA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=G74YOGd+KW6PfFvdswhoDzYcIuStPXuwuhYirfhXwiM=; b=DEwpErIYHkUeEO+J3DV+RqMDqaaEKqSq7i0W2Fij7ULpeGB3dBEnF6sauCcy+Jbmu1 Z4cfc/wjfLczkMFs7dCffvfdS3TDEmVjpK1EAPlxFXwYAQkiA4K6NmjrqXdlefI1B86v 16x2rs7OsuIkwScByJn1sIo5EEUyLzIilDvGtqONtVTuOygMRlypkdj9/48MKhKSWmFZ ILr4Z3JdcJTfCn5iOJrEl+azTIubW+26ZbGvFBet5F571BIlZkkx3kmXbxmyTRHwS8cV vrfjyETodpu5TQsEbZSuXZaxfbcva83YwrdV0pVRSWVKZ2yidyQJmvMIlngjvWEVD+KG AYMQ== X-Gm-Message-State: AOAM533Rqy0rLxU4zNfMTj4gPeRgBuAgKNUDJK1Dc+jJH8b93FZkYzlR QlqH9snRos7TEX9/4Xx0QGRqTQbevm+b1mJdc++M5Tep3G1CrcZbMJLWseXvdjWNVuSYUNf20P6 grFMQE+Bb0wFRu1R/2WXSvsWnYYl1fe7CVv/RR1hAmMoPvVncsJGOMX8m1QnjuMsAfg8mbm2M X-Google-Smtp-Source: ABdhPJwbnxlqSVC8vvWdQE7kZzWG12dhBh7iFh7S+OO+ZoQ6+KRaSZGgMcswktkOPo+eA2A2fTdo/1M58Umh X-Received: from bgardon.sea.corp.google.com ([2620:15c:100:202:a2d0:faec:7d8b:2e0b]) (user=bgardon job=sendgmr) by 2002:a17:90a:ba13:b0:1cb:6296:ce41 with SMTP id s19-20020a17090aba1300b001cb6296ce41mr1224016pjr.104.1649711449422; Mon, 11 Apr 2022 14:10:49 -0700 (PDT) Date: Mon, 11 Apr 2022 14:10:12 -0700 In-Reply-To: <20220411211015.3091615-1-bgardon@google.com> Message-Id: <20220411211015.3091615-8-bgardon@google.com> Mime-Version: 1.0 References: <20220411211015.3091615-1-bgardon@google.com> X-Mailer: git-send-email 2.35.1.1178.g4f1659d476-goog Subject: [PATCH v4 07/10] KVM: x86/MMU: Allow NX huge pages to be disabled on a per-vm basis From: Ben Gardon To: linux-kernel@vger.kernel.org, kvm@vger.kernel.org Cc: Paolo Bonzini , Peter Xu , Sean Christopherson , Peter Shier , David Dunn , Junaid Shahid , Jim Mattson , David Matlack , Mingwei Zhang , Jing Zhang , Ben Gardon Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" In some cases, the NX hugepage mitigation for iTLB multihit is not needed for all guests on a host. Allow disabling the mitigation on a per-VM basis to avoid the performance hit of NX hugepages on trusted workloads. Reviewed-by: David Matlack Signed-off-by: Ben Gardon --- Documentation/virt/kvm/api.rst | 11 +++++++++++ arch/x86/include/asm/kvm_host.h | 2 ++ arch/x86/kvm/mmu.h | 10 ++++++---- arch/x86/kvm/mmu/mmu.c | 2 +- arch/x86/kvm/mmu/spte.c | 7 ++++--- arch/x86/kvm/mmu/spte.h | 3 ++- arch/x86/kvm/mmu/tdp_mmu.c | 3 ++- arch/x86/kvm/x86.c | 6 ++++++ include/uapi/linux/kvm.h | 1 + 9 files changed, 35 insertions(+), 10 deletions(-) diff --git a/Documentation/virt/kvm/api.rst b/Documentation/virt/kvm/api.rst index 72183ae628f7..31fb002632bb 100644 --- a/Documentation/virt/kvm/api.rst +++ b/Documentation/virt/kvm/api.rst @@ -7855,6 +7855,17 @@ At this time, KVM_PMU_CAP_DISABLE is the only capabi= lity. Setting this capability will disable PMU virtualization for that VM. Usermode should adjust CPUID leaf 0xA to reflect that the PMU is disabled. =20 +8.36 KVM_CAP_VM_DISABLE_NX_HUGE_PAGES +--------------------------- + +:Capability KVM_CAP_PMU_CAPABILITY +:Architectures: x86 +:Type: vm + +This capability disables the NX huge pages mitigation for iTLB MULTIHIT. + +The capability has no effect if the nx_huge_pages module parameter is not = set. + 9. Known KVM API problems =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D =20 diff --git a/arch/x86/include/asm/kvm_host.h b/arch/x86/include/asm/kvm_hos= t.h index 2c20f715f009..b8ab4fa7d4b2 100644 --- a/arch/x86/include/asm/kvm_host.h +++ b/arch/x86/include/asm/kvm_host.h @@ -1240,6 +1240,8 @@ struct kvm_arch { hpa_t hv_root_tdp; spinlock_t hv_root_tdp_lock; #endif + + bool disable_nx_huge_pages; }; =20 struct kvm_vm_stat { diff --git a/arch/x86/kvm/mmu.h b/arch/x86/kvm/mmu.h index 671cfeccf04e..20d12e5b0040 100644 --- a/arch/x86/kvm/mmu.h +++ b/arch/x86/kvm/mmu.h @@ -173,10 +173,12 @@ struct kvm_page_fault { int kvm_tdp_page_fault(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault= ); =20 extern int nx_huge_pages; -static inline bool is_nx_huge_page_enabled(void) +static inline bool is_nx_huge_page_enabled(struct kvm *kvm) { - return READ_ONCE(nx_huge_pages); + return READ_ONCE(nx_huge_pages) && + !kvm->arch.disable_nx_huge_pages; } +void kvm_update_nx_huge_pages(struct kvm *kvm); =20 static inline int kvm_mmu_do_page_fault(struct kvm_vcpu *vcpu, gpa_t cr2_o= r_gpa, u32 err, bool prefetch) @@ -191,8 +193,8 @@ static inline int kvm_mmu_do_page_fault(struct kvm_vcpu= *vcpu, gpa_t cr2_or_gpa, .user =3D err & PFERR_USER_MASK, .prefetch =3D prefetch, .is_tdp =3D likely(vcpu->arch.mmu->page_fault =3D=3D kvm_tdp_page_fault), - .nx_huge_page_workaround_enabled =3D is_nx_huge_page_enabled(), - + .nx_huge_page_workaround_enabled =3D + is_nx_huge_page_enabled(vcpu->kvm), .max_level =3D KVM_MAX_HUGEPAGE_LEVEL, .req_level =3D PG_LEVEL_4K, .goal_level =3D PG_LEVEL_4K, diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c index caaa610b7878..149f353105f4 100644 --- a/arch/x86/kvm/mmu/mmu.c +++ b/arch/x86/kvm/mmu/mmu.c @@ -6144,7 +6144,7 @@ static void __set_nx_huge_pages(bool val) nx_huge_pages =3D itlb_multihit_kvm_mitigation =3D val; } =20 -static void kvm_update_nx_huge_pages(struct kvm *kvm) +void kvm_update_nx_huge_pages(struct kvm *kvm) { mutex_lock(&kvm->slots_lock); kvm_mmu_zap_all_fast(kvm); diff --git a/arch/x86/kvm/mmu/spte.c b/arch/x86/kvm/mmu/spte.c index 4739b53c9734..877ad30bc7ad 100644 --- a/arch/x86/kvm/mmu/spte.c +++ b/arch/x86/kvm/mmu/spte.c @@ -116,7 +116,7 @@ bool make_spte(struct kvm_vcpu *vcpu, struct kvm_mmu_pa= ge *sp, spte |=3D spte_shadow_accessed_mask(spte); =20 if (level > PG_LEVEL_4K && (pte_access & ACC_EXEC_MASK) && - is_nx_huge_page_enabled()) { + is_nx_huge_page_enabled(vcpu->kvm)) { pte_access &=3D ~ACC_EXEC_MASK; } =20 @@ -215,7 +215,8 @@ static u64 make_spte_executable(u64 spte) * This is used during huge page splitting to build the SPTEs that make up= the * new page table. */ -u64 make_huge_page_split_spte(u64 huge_spte, int huge_level, int index) +u64 make_huge_page_split_spte(struct kvm *kvm, u64 huge_spte, int huge_lev= el, + int index) { u64 child_spte; int child_level; @@ -243,7 +244,7 @@ u64 make_huge_page_split_spte(u64 huge_spte, int huge_l= evel, int index) * When splitting to a 4K page, mark the page executable as the * NX hugepage mitigation no longer applies. */ - if (is_nx_huge_page_enabled()) + if (is_nx_huge_page_enabled(kvm)) child_spte =3D make_spte_executable(child_spte); } =20 diff --git a/arch/x86/kvm/mmu/spte.h b/arch/x86/kvm/mmu/spte.h index 73f12615416f..e4142caff4b1 100644 --- a/arch/x86/kvm/mmu/spte.h +++ b/arch/x86/kvm/mmu/spte.h @@ -415,7 +415,8 @@ bool make_spte(struct kvm_vcpu *vcpu, struct kvm_mmu_pa= ge *sp, unsigned int pte_access, gfn_t gfn, kvm_pfn_t pfn, u64 old_spte, bool prefetch, bool can_unsync, bool host_writable, u64 *new_spte); -u64 make_huge_page_split_spte(u64 huge_spte, int huge_level, int index); +u64 make_huge_page_split_spte(struct kvm *kvm, u64 huge_spte, int huge_lev= el, + int index); u64 make_nonleaf_spte(u64 *child_pt, bool ad_disabled); u64 make_mmio_spte(struct kvm_vcpu *vcpu, u64 gfn, unsigned int access); u64 mark_spte_for_access_track(u64 spte); diff --git a/arch/x86/kvm/mmu/tdp_mmu.c b/arch/x86/kvm/mmu/tdp_mmu.c index 566548a3efa7..03aa1e0f60e2 100644 --- a/arch/x86/kvm/mmu/tdp_mmu.c +++ b/arch/x86/kvm/mmu/tdp_mmu.c @@ -1469,7 +1469,8 @@ static int tdp_mmu_split_huge_page(struct kvm *kvm, s= truct tdp_iter *iter, * not been linked in yet and thus is not reachable from any other CPU. */ for (i =3D 0; i < PT64_ENT_PER_PAGE; i++) - sp->spt[i] =3D make_huge_page_split_spte(huge_spte, level, i); + sp->spt[i] =3D make_huge_page_split_spte(kvm, huge_spte, + level, i); =20 /* * Replace the huge spte with a pointer to the populated lower level diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c index ab336f7c82e4..b810ea45f965 100644 --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c @@ -4286,6 +4286,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, lon= g ext) case KVM_CAP_SYS_ATTRIBUTES: case KVM_CAP_VAPIC: case KVM_CAP_ENABLE_CAP: + case KVM_CAP_VM_DISABLE_NX_HUGE_PAGES: r =3D 1; break; case KVM_CAP_EXIT_HYPERCALL: @@ -6079,6 +6080,11 @@ int kvm_vm_ioctl_enable_cap(struct kvm *kvm, } mutex_unlock(&kvm->lock); break; + case KVM_CAP_VM_DISABLE_NX_HUGE_PAGES: + kvm->arch.disable_nx_huge_pages =3D true; + kvm_update_nx_huge_pages(kvm); + r =3D 0; + break; default: r =3D -EINVAL; break; diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h index dd1d8167e71f..7155488164bd 100644 --- a/include/uapi/linux/kvm.h +++ b/include/uapi/linux/kvm.h @@ -1148,6 +1148,7 @@ struct kvm_ppc_resize_hpt { #define KVM_CAP_PMU_CAPABILITY 212 #define KVM_CAP_DISABLE_QUIRKS2 213 #define KVM_CAP_VM_TSC_CONTROL 214 +#define KVM_CAP_VM_DISABLE_NX_HUGE_PAGES 215 =20 #ifdef KVM_CAP_IRQ_ROUTING =20 --=20 2.35.1.1178.g4f1659d476-goog From nobody Mon May 11 07:46:23 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3B8C7C433FE for ; Mon, 11 Apr 2022 21:11:15 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1350170AbiDKVN2 (ORCPT ); Mon, 11 Apr 2022 17:13:28 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:39124 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1350092AbiDKVNL (ORCPT ); Mon, 11 Apr 2022 17:13:11 -0400 Received: from mail-yw1-x1149.google.com (mail-yw1-x1149.google.com [IPv6:2607:f8b0:4864:20::1149]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 460FA2B1AA for ; Mon, 11 Apr 2022 14:10:52 -0700 (PDT) Received: by mail-yw1-x1149.google.com with SMTP id 00721157ae682-2ec0490dc1bso46498837b3.5 for ; Mon, 11 Apr 2022 14:10:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=5cDHQ7aYk/4WlSHe8abtE794AVjCSbjoziFcjScQIDg=; b=EHo4PZTgbcB/cGBBAiyRYVsvxPNAoeEZ5fN/cWjy/KeYesKX7nH4FnJDFlKe21/DM5 jLs2RPbnHA8OBCDkdCL05fYvofTYE4j2wO1J6+MhUjdP3HiCHMmgToc+a39Nd5xLiyjD UO4K/gp66K4tEZNuqVFocRHHlJgLTLzZRHg9XBRDQZRU/k5Dw2XRLvr6YHTkAaW6FICH Rda7WzMpBonouqjbqwkXxZkQCF1jJDXTZKqShJJlIn+MMY2fCqkf6yfWN8+kgPySfL2F DrTUYHik/1yNic3JcSos6vItGPm5wvzqodPdf0Qkywemw6rXS0uD4B9eLp/F4O78Kw8A mKWg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=5cDHQ7aYk/4WlSHe8abtE794AVjCSbjoziFcjScQIDg=; b=cv35noDgvJoZ53cGp7qDuReWyL0XWT/VKwqlOQYrSbI3GaSNTjejJfjCDfHhK7jn4f YeFoIR/fZ7gboSrLpFu6TZcUX/LUwnojmJEMKLBL/EJG1BFVkyRVDScevXoxYsaC9GbS mTDJzWMpZ7q4oYdTqO5BpZie6lps2JA2s+a9f/3kR4SIbFrynmwcNwoVnXCYTYUwLBwD Be4xMCVFmjAaZ7jMnZf8mExfEqRKCE1Jjmv1PkccLxHmsce/5RyDKZYbpONzJHwt/dJN DpoUvOk6aUgnni26Z0JuaGnjoup9zPEMvS9HGL06/ps+brkC4AROQepe9bAHhyvoVpfF lqzQ== X-Gm-Message-State: AOAM531C3Nmp7BbPxNBC7zdBQNCtbjKtT6EB1+knSOKsgXr/hCk224No mwpPl3wJbM9FKrVwKohwsZIO8Xp0vs4zPMIt1DpnSlGqp6jq2N4WlA6bhk5TzHQT3DjfgtvsizJ iRjQxq4+97430T2ZFLfU4uQAgCQNf3F1Iydm4fyCoZu183WIBG+wB3xh5xfvvBNy+mhPoWWeg X-Google-Smtp-Source: ABdhPJzYux8ibwEUBRsQsI9vPNp1Exnwx/91xo77Pgzf9e9e6BbohC6/2rA2NAZ7cIlMzGKrYQCU6X1a0A5t X-Received: from bgardon.sea.corp.google.com ([2620:15c:100:202:a2d0:faec:7d8b:2e0b]) (user=bgardon job=sendgmr) by 2002:a81:413:0:b0:2ec:31d7:7e60 with SMTP id 19-20020a810413000000b002ec31d77e60mr5057689ywe.62.1649711451242; Mon, 11 Apr 2022 14:10:51 -0700 (PDT) Date: Mon, 11 Apr 2022 14:10:13 -0700 In-Reply-To: <20220411211015.3091615-1-bgardon@google.com> Message-Id: <20220411211015.3091615-9-bgardon@google.com> Mime-Version: 1.0 References: <20220411211015.3091615-1-bgardon@google.com> X-Mailer: git-send-email 2.35.1.1178.g4f1659d476-goog Subject: [PATCH v4 08/10] KVM: x86: Fix errant brace in KVM capability handling From: Ben Gardon To: linux-kernel@vger.kernel.org, kvm@vger.kernel.org Cc: Paolo Bonzini , Peter Xu , Sean Christopherson , Peter Shier , David Dunn , Junaid Shahid , Jim Mattson , David Matlack , Mingwei Zhang , Jing Zhang , Ben Gardon Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The braces around the KVM_CAP_XSAVE2 block also surround the KVM_CAP_PMU_CAPABILITY block, likely the result of a merge issue. Simply move the curly brace back to where it belongs. Fixes: ba7bb663f5547 ("KVM: x86: Provide per VM capability for disabling PM= U virtualization") Signed-off-by: Ben Gardon --- arch/x86/kvm/x86.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c index b810ea45f965..de1d211f8aa3 100644 --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c @@ -4383,10 +4383,10 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, l= ong ext) if (r < sizeof(struct kvm_xsave)) r =3D sizeof(struct kvm_xsave); break; + } case KVM_CAP_PMU_CAPABILITY: r =3D enable_pmu ? KVM_CAP_PMU_VALID_MASK : 0; break; - } case KVM_CAP_DISABLE_QUIRKS2: r =3D KVM_X86_VALID_QUIRKS; break; --=20 2.35.1.1178.g4f1659d476-goog From nobody Mon May 11 07:46:23 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1EB5FC433FE for ; Mon, 11 Apr 2022 21:11:26 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1345665AbiDKVNi (ORCPT ); Mon, 11 Apr 2022 17:13:38 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:39212 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1350106AbiDKVNM (ORCPT ); Mon, 11 Apr 2022 17:13:12 -0400 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 D7E282B1BD for ; Mon, 11 Apr 2022 14:10:53 -0700 (PDT) Received: by mail-pg1-x549.google.com with SMTP id q13-20020a638c4d000000b003821725ad66so9429484pgn.23 for ; Mon, 11 Apr 2022 14:10:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=dXlFBD0LldYOfRc7OaKD0wMXPzi3maZCvF8rPD26eTI=; b=od645DgDIiqdxXTXIqTecH/cdEHvdo6xF2qu5T02FMQ19MQNLm9xVN/ZO9o0v93qEW 6kpH4zKRGD2sT+LExaIzj5l4Hp7CRMRF8bLpq6s5ihDNFvAbSv4zOT9ywEHYI53vyLTR jCz9NWc9KdYyem5akZTphuk/sjQ6Tde/iYyfxkuxBjXqop1zMCiSZo7KfPuJm6MACxQU oglTlvRr2XBhY42HCju5FgQRrDnZAsCB7vq3ca9jbt2wTTIBNWEM6zvV3lTVHmQOJ7Dy uYZ4A4QY+6CqedZGz+Q5ng6Q9du0pBMjStji3X/hcVlUKbT3KfYkLQUsCvdH/R4Ku66X 4gnQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=dXlFBD0LldYOfRc7OaKD0wMXPzi3maZCvF8rPD26eTI=; b=w6jEbkSlkLpVWwhD0fo/MM11zMMHUMZOq2hlaGDyc0iL42seP6u/dkpfnXQBe2IteV Qml3b/FjJB9eLGazfDXuG0BLEK9Q3FKFyLRCnZ8uS4A4ZpA+K8G0+wjYLhCc/PgjAKMe hMMuEFcP1STJkGyITEyOrGquWUQeMKNrGjkIj5ZaJCoz1rzH8uw9ApRmm3Vpyz9Gdlzl ANORu1tPxn+jU6O3EXvOAkFDpon5zoM19oyrmchF2IzEZdxc4FyDFP/2851xD4o3Eak2 m6QcW+7Q3S0ilgdXInuUYBMzNPT495RnAj7vdi/phAjVEo+HXy/ZnRb0fdYapI8u/5D7 9GYg== X-Gm-Message-State: AOAM532LHsNBbXg+6qR9MS7lHQdhF15FjX4tSGwByDAkyQsC5Ig9s7pI TLQNizsO6hLOw8yTVG+4fqNAUELFQoIYLnSuidX1qK8+8RN97OuzFgrnxajHXA28YuHp7H3Kskg EWbOGubvY5lHaojX9IQ3KY0EuZEnmhRHsky50qyqQD39KA7K0WW2zyp3HqvF2yiI7MeSYOgbL X-Google-Smtp-Source: ABdhPJxRBDuMX+1iIQMZOMQEGWUuODV9pdUUYDXB5DzdeWHVI/JBHhK3LPtoD+bM0n1KR1cloYlAQTXVNNqc X-Received: from bgardon.sea.corp.google.com ([2620:15c:100:202:a2d0:faec:7d8b:2e0b]) (user=bgardon job=sendgmr) by 2002:a17:90b:1c87:b0:1ca:f4e:4fbe with SMTP id oo7-20020a17090b1c8700b001ca0f4e4fbemr1168462pjb.159.1649711452989; Mon, 11 Apr 2022 14:10:52 -0700 (PDT) Date: Mon, 11 Apr 2022 14:10:14 -0700 In-Reply-To: <20220411211015.3091615-1-bgardon@google.com> Message-Id: <20220411211015.3091615-10-bgardon@google.com> Mime-Version: 1.0 References: <20220411211015.3091615-1-bgardon@google.com> X-Mailer: git-send-email 2.35.1.1178.g4f1659d476-goog Subject: [PATCH v4 09/10] KVM: x86/MMU: Require reboot permission to disable NX hugepages From: Ben Gardon To: linux-kernel@vger.kernel.org, kvm@vger.kernel.org Cc: Paolo Bonzini , Peter Xu , Sean Christopherson , Peter Shier , David Dunn , Junaid Shahid , Jim Mattson , David Matlack , Mingwei Zhang , Jing Zhang , Ben Gardon Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Ensure that the userspace actor attempting to disable NX hugepages has permission to reboot the system. Since disabling NX hugepages would allow a guest to crash the system, it is similar to reboot permissions. This approach is the simplest permission gating, but passing a file descriptor opened for write for the module parameter would also work well and be more precise. The latter approach was suggested by Sean Christopherson. Suggested-by: Jim Mattson Signed-off-by: Ben Gardon --- Documentation/virt/kvm/api.rst | 2 ++ arch/x86/kvm/x86.c | 9 +++++++++ 2 files changed, 11 insertions(+) diff --git a/Documentation/virt/kvm/api.rst b/Documentation/virt/kvm/api.rst index 31fb002632bb..021452a9fa91 100644 --- a/Documentation/virt/kvm/api.rst +++ b/Documentation/virt/kvm/api.rst @@ -7861,6 +7861,8 @@ should adjust CPUID leaf 0xA to reflect that the PMU = is disabled. :Capability KVM_CAP_PMU_CAPABILITY :Architectures: x86 :Type: vm +:Returns 0 on success, -EPERM if the userspace process does not + have CAP_SYS_BOOT =20 This capability disables the NX huge pages mitigation for iTLB MULTIHIT. =20 diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c index de1d211f8aa3..8d3d6c48c5ec 100644 --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c @@ -6081,6 +6081,15 @@ int kvm_vm_ioctl_enable_cap(struct kvm *kvm, mutex_unlock(&kvm->lock); break; case KVM_CAP_VM_DISABLE_NX_HUGE_PAGES: + /* + * Since the risk of disabling NX hugepages is a guest crashing + * the system, ensure the userspace process has permission to + * reboot the system. + */ + if (!capable(CAP_SYS_BOOT)) { + r =3D -EPERM; + break; + } kvm->arch.disable_nx_huge_pages =3D true; kvm_update_nx_huge_pages(kvm); r =3D 0; --=20 2.35.1.1178.g4f1659d476-goog From nobody Mon May 11 07:46:23 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4DACFC433F5 for ; Mon, 11 Apr 2022 21:11:20 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1344499AbiDKVNa (ORCPT ); Mon, 11 Apr 2022 17:13:30 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:39644 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1350081AbiDKVNQ (ORCPT ); Mon, 11 Apr 2022 17:13:16 -0400 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 949152B24F for ; Mon, 11 Apr 2022 14:10:55 -0700 (PDT) Received: by mail-pj1-x1049.google.com with SMTP id b8-20020a17090a488800b001cb7eb98cbfso243497pjh.9 for ; Mon, 11 Apr 2022 14:10:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=xIMnek+At8iLPkwADBkZ7XrRr/vdRBqsK9zci+WHfIA=; b=C4dFQ0ocxToI8CY7sDWjXFzHFgdTdFWswyceRjb37yOLdjfoDBtbtvTmi5cGq1VEad 7w8VZnkp/JJLp1koNV5oGegMEnys1FuotSD/VT2E99+gGSCbtJHDbEHlaIItSlSUO+tb eviNS42ugJl3zF5thORrX6+krLI00hAQmWFDh59sequdz26pxJLmn5eHdd2XQ8fEEaX1 GQK8xmTzvsluF8s4Zp/5sBH4besgH876R3NeNfZ7AHjIfn/OfaxNPDHjyeNmoIJo+rXM h58xMxL76jasLP7j1ajCTOzysJml3k8TgVcV+noGb9bO3iSj+K1onUAcK60/t9nG3NuV 9XPA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=xIMnek+At8iLPkwADBkZ7XrRr/vdRBqsK9zci+WHfIA=; b=bc8A1nuY4t1wSRP1IRI6Cp0DVr5lHUxWv+6B9g9V1YPB9c4Pidk9JflO5gNScv0eD5 2cuuFSydacQX2ifojAQkU8tBjXAcXHSbWLmuNli/hlsIn8N9vOAo2YVJVJXjBJ1Ddrkn QoEz7rUU00Qzn3Wh25vqosq90K6kWOaKqrKzIQMugLsDcaL1EDBWRjcivmsx+37eLDFq zB3wET8wFdawhy+3drb83JcmFmDvm1WbOhhlKMPLjeOjd972Pi3zozXzVrDfwRLwK+2C NrJhqY/cGig8Aqi7ApfrdWcWJutv8HLpAK/sv3njTzN/N/MtN3RuSeIR188Idm5ej0r/ KCTA== X-Gm-Message-State: AOAM533oIAybMdRq2lIPKY7c6Y4Ry1ELUxHa1jnyA/8NqZlrLD4SjQSC sMqS+V28ImObDeHdNVU8vXzDBD5r9wRzDKxpfpGnBgTQqan8UQFJrR7NJGJx07y8PBJq89GFwvm 7IqZZIzkND8qPLmNU9tvLbrqJ6rLqjCny8RT8lvMVp5vdmAdBH5LqZtX2tZXF4ITe5gcDnGP0 X-Google-Smtp-Source: ABdhPJy2WkMcnAC3gL8ghKY5MA9VSdRNJhjdAS3w/erZboLxL3Zrns0cwsriLs/zATnsIQVyFpAaL6sUNN0D X-Received: from bgardon.sea.corp.google.com ([2620:15c:100:202:a2d0:faec:7d8b:2e0b]) (user=bgardon job=sendgmr) by 2002:a17:902:728f:b0:156:24d3:ae1a with SMTP id d15-20020a170902728f00b0015624d3ae1amr34419549pll.9.1649711454954; Mon, 11 Apr 2022 14:10:54 -0700 (PDT) Date: Mon, 11 Apr 2022 14:10:15 -0700 In-Reply-To: <20220411211015.3091615-1-bgardon@google.com> Message-Id: <20220411211015.3091615-11-bgardon@google.com> Mime-Version: 1.0 References: <20220411211015.3091615-1-bgardon@google.com> X-Mailer: git-send-email 2.35.1.1178.g4f1659d476-goog Subject: [PATCH v4 10/10] KVM: selftests: Test disabling NX hugepages on a VM From: Ben Gardon To: linux-kernel@vger.kernel.org, kvm@vger.kernel.org Cc: Paolo Bonzini , Peter Xu , Sean Christopherson , Peter Shier , David Dunn , Junaid Shahid , Jim Mattson , David Matlack , Mingwei Zhang , Jing Zhang , Ben Gardon Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add an argument to the NX huge pages test to test disabling the feature on a VM using the new capability. Signed-off-by: Ben Gardon --- .../selftests/kvm/include/kvm_util_base.h | 2 + tools/testing/selftests/kvm/lib/kvm_util.c | 19 ++++++- .../selftests/kvm/x86_64/nx_huge_pages_test.c | 53 +++++++++++++++---- 3 files changed, 64 insertions(+), 10 deletions(-) diff --git a/tools/testing/selftests/kvm/include/kvm_util_base.h b/tools/te= sting/selftests/kvm/include/kvm_util_base.h index f9c2ac0a5b97..15f24be6d93f 100644 --- a/tools/testing/selftests/kvm/include/kvm_util_base.h +++ b/tools/testing/selftests/kvm/include/kvm_util_base.h @@ -412,4 +412,6 @@ uint64_t vm_get_single_stat(struct kvm_vm *vm, const ch= ar *stat_name); =20 uint32_t guest_get_vcpuid(void); =20 +int vm_disable_nx_huge_pages(struct kvm_vm *vm); + #endif /* SELFTEST_KVM_UTIL_BASE_H */ diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/sel= ftests/kvm/lib/kvm_util.c index 833c7e63d62d..5fa5608eef03 100644 --- a/tools/testing/selftests/kvm/lib/kvm_util.c +++ b/tools/testing/selftests/kvm/lib/kvm_util.c @@ -112,6 +112,15 @@ int vm_check_cap(struct kvm_vm *vm, long cap) return ret; } =20 +static int __vm_enable_cap(struct kvm_vm *vm, struct kvm_enable_cap *cap) +{ + int ret; + + ret =3D ioctl(vm->fd, KVM_ENABLE_CAP, cap); + + return ret; +} + /* VM Enable Capability * * Input Args: @@ -128,7 +137,7 @@ int vm_enable_cap(struct kvm_vm *vm, struct kvm_enable_= cap *cap) { int ret; =20 - ret =3D ioctl(vm->fd, KVM_ENABLE_CAP, cap); + ret =3D __vm_enable_cap(vm, cap); TEST_ASSERT(ret =3D=3D 0, "KVM_ENABLE_CAP IOCTL failed,\n" " rc: %i errno: %i", ret, errno); =20 @@ -2662,3 +2671,11 @@ uint64_t vm_get_single_stat(struct kvm_vm *vm, const= char *stat_name) stat_name, ret); return data; } + +int vm_disable_nx_huge_pages(struct kvm_vm *vm) +{ + struct kvm_enable_cap cap =3D { 0 }; + + cap.cap =3D KVM_CAP_VM_DISABLE_NX_HUGE_PAGES; + return __vm_enable_cap(vm, &cap); +} diff --git a/tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c b/tool= s/testing/selftests/kvm/x86_64/nx_huge_pages_test.c index 3f21726b22c7..f8edf7910950 100644 --- a/tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +++ b/tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c @@ -13,6 +13,8 @@ #include #include #include +#include +#include =20 #include #include "kvm_util.h" @@ -77,14 +79,41 @@ static void check_split_count(struct kvm_vm *vm, int ex= pected_splits) expected_splits, actual_splits); } =20 -int main(int argc, char **argv) +void run_test(bool disable_nx) { struct kvm_vm *vm; struct timespec ts; void *hva; + int r; =20 vm =3D vm_create_default(0, 0, guest_code); =20 + if (disable_nx) { + kvm_check_cap(KVM_CAP_VM_DISABLE_NX_HUGE_PAGES); + + /* + * Check if this process has the reboot permissions needed to + * disable NX huge pages on a VM. + * + * The reboot call below will never have any effect because + * the magic values are not set correctly, however the + * permission check is done before the magic value check. + */ + r =3D syscall(SYS_reboot, 0, 0, 0, NULL); + if (errno =3D=3D EPERM) { + r =3D vm_disable_nx_huge_pages(vm); + TEST_ASSERT(r =3D=3D EPERM, + "This process should not have permission to disable NX huge pages"= ); + return; + } + + TEST_ASSERT(errno =3D=3D EINVAL, + "Reboot syscall should fail with -EINVAL"); + + r =3D vm_disable_nx_huge_pages(vm); + TEST_ASSERT(!r, "Disabling NX huge pages should not fail if process has = reboot permissions"); + } + vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS_HUGETLB, HPAGE_GPA, HPAGE_SLOT, HPAGE_SLOT_NPAGES, 0); @@ -118,21 +147,21 @@ int main(int argc, char **argv) * to be remapped at 4k. */ vcpu_run(vm, 0); - check_2m_page_count(vm, 1); - check_split_count(vm, 1); + check_2m_page_count(vm, disable_nx ? 2 : 1); + check_split_count(vm, disable_nx ? 0 : 1); =20 /* * Executing from the third huge page (previously unaccessed) will * cause part to be mapped at 4k. */ vcpu_run(vm, 0); - check_2m_page_count(vm, 1); - check_split_count(vm, 2); + check_2m_page_count(vm, disable_nx ? 3 : 1); + check_split_count(vm, disable_nx ? 0 : 2); =20 /* Reading from the first huge page again should have no effect. */ vcpu_run(vm, 0); - check_2m_page_count(vm, 1); - check_split_count(vm, 2); + check_2m_page_count(vm, disable_nx ? 3 : 1); + check_split_count(vm, disable_nx ? 0 : 2); =20 /* * Give recovery thread time to run. The wrapper script sets @@ -145,7 +174,7 @@ int main(int argc, char **argv) /* * Now that the reclaimer has run, all the split pages should be gone. */ - check_2m_page_count(vm, 1); + check_2m_page_count(vm, disable_nx ? 3 : 1); check_split_count(vm, 0); =20 /* @@ -153,10 +182,16 @@ int main(int argc, char **argv) * reading from it causes a huge page mapping to be installed. */ vcpu_run(vm, 0); - check_2m_page_count(vm, 2); + check_2m_page_count(vm, disable_nx ? 3 : 2); check_split_count(vm, 0); =20 kvm_vm_free(vm); +} + +int main(int argc, char **argv) +{ + run_test(false); + run_test(true); =20 return 0; } --=20 2.35.1.1178.g4f1659d476-goog