From patchwork Wed Mar 10 00:30:21 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jing Zhang X-Patchwork-Id: 12126773 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-26.3 required=3.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT,USER_IN_DEF_DKIM_WL autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 50178C43619 for ; Wed, 10 Mar 2021 00:31:47 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 3FB3A65105 for ; Wed, 10 Mar 2021 00:31:47 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231439AbhCJAbQ (ORCPT ); Tue, 9 Mar 2021 19:31:16 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:47992 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231367AbhCJAan (ORCPT ); Tue, 9 Mar 2021 19:30:43 -0500 Received: from mail-io1-xd49.google.com (mail-io1-xd49.google.com [IPv6:2607:f8b0:4864:20::d49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B820AC061762 for ; Tue, 9 Mar 2021 16:30:43 -0800 (PST) Received: by mail-io1-xd49.google.com with SMTP id d8so11602057ion.10 for ; Tue, 09 Mar 2021 16:30:43 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=w4HWO7BOc3rd93ENppTFarD1eUekczKbOeXBNH9YdnE=; b=ehzWMPESd1qEKYF5eIXAG8PO252zJXS5nxBQ6cL/dgn9nfrMa9XztHs6xQqzzmZRw1 /vmJRDYFspuSWYNONt84tXe5Gu+XWSVpDS5/o/G8289D8bznR36qNIukjdSFnR236v6F lDW/d7rA405/eDJ1BDISM/F9ADuZhJCFV1zXwIKusXv5B03qHthdli8Qh8dqfE5iPUgH yf5v22t4HjFjfXnEYc8htmJBikGzI8CaWUSpNy0ECW/4vcqBKw8OO7hmsGF9RQIDx64m AUoIkz2MzIRG1fX85vhR9PCuMa+7RriKV/y9qtBeP8FIOHqqyYJTe7ySReBhXJalb+S6 pgng== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=w4HWO7BOc3rd93ENppTFarD1eUekczKbOeXBNH9YdnE=; b=Mvmv5uvfm3bhIyiGA5RO/NgNDrp9p7KN4ZbGYnuxhmpHqnMRgeeFQZK8oyQE9/e5oY SrgnYUbJenRRADXNM97TCNzAEzhVjfj1AF7GBQ2LWKGMAYThwuayHgDaZdVS/s+iHMul hh7A8mYvvf/pwxZI1DCtm95PcZGNFSL/4QGW4W+XrAdddlIZqp4ln3g8jpn4Z/oBMYdp xKQcF5eosE+6/hqdmuzWVgsarJ/bAUo8Bte8LAWsMKlxb5luxTd7hJA+z8TGCjY9uIZ2 BwSdf9IUrPSQVHMd9h2CWe0bCz+P8HgYT3tCI0yhy71yUBJkPgAcoJYtLnAPoBJo7MHA YKog== X-Gm-Message-State: AOAM5317bZnoa6xBP/HAtnDsrCCxxaTUw9buFEuIUV7kAOZyhOQ+jy/u a6oqJefZ1MHdZknx9VNHsEGhC7I9izI06bc2/OlmM4fkW2G+hyz4JLFtHUyWd3Niw/QsBwlQ8Lm cW9kmapyDUdRCMSUFbbv6+mc3VmmATpzdRGKH93hMyR2uX+X+mCDymncmRtfFX5ypW/M8B6Y= X-Google-Smtp-Source: ABdhPJyRIDsfQsiUcP3akPSY+zemsgHPSz3ZV8SsEBVLSILX/2HwE0zgNRlxmwAlt7ilcx04LhvjxO/9BTJT4PSeEg== X-Received: from jingzhangos.c.googlers.com ([fda3:e722:ac3:10:2b:ff92:c0a8:513]) (user=jingzhangos job=sendgmr) by 2002:a5d:8c8f:: with SMTP id g15mr603463ion.162.1615336243044; Tue, 09 Mar 2021 16:30:43 -0800 (PST) Date: Wed, 10 Mar 2021 00:30:21 +0000 In-Reply-To: <20210310003024.2026253-1-jingzhangos@google.com> Message-Id: <20210310003024.2026253-2-jingzhangos@google.com> Mime-Version: 1.0 References: <20210310003024.2026253-1-jingzhangos@google.com> X-Mailer: git-send-email 2.30.1.766.gb4fecdf3b7-goog Subject: [RFC PATCH 1/4] KVM: stats: Separate statistics name strings from debugfs code From: Jing Zhang To: KVM , KVM ARM , Linux MIPS , KVM PPC , Linux S390 , Linux kselftest , Paolo Bonzini , Marc Zyngier , James Morse , Julien Thierry , Suzuki K Poulose , Will Deacon , Huacai Chen , Aleksandar Markovic , Thomas Bogendoerfer , Paul Mackerras , Christian Borntraeger , Janosch Frank , David Hildenbrand , Cornelia Huck , Claudio Imbrenda , Sean Christopherson , Vitaly Kuznetsov , Jim Mattson , Peter Shier , Oliver Upton , David Rientjes , Emanuele Giuseppe Esposito Cc: Jing Zhang Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Prepare the statistics name strings for supporting binary format aggregated statistics data retrieval. No functional change intended. Signed-off-by: Jing Zhang --- arch/arm64/kvm/guest.c | 47 ++++-- arch/mips/kvm/mips.c | 114 ++++++++++---- arch/powerpc/kvm/book3s.c | 107 +++++++++---- arch/powerpc/kvm/booke.c | 84 +++++++--- arch/s390/kvm/kvm-s390.c | 320 ++++++++++++++++++++++++++------------ arch/x86/kvm/x86.c | 127 ++++++++++----- include/linux/kvm_host.h | 31 +++- 7 files changed, 589 insertions(+), 241 deletions(-) diff --git a/arch/arm64/kvm/guest.c b/arch/arm64/kvm/guest.c index 9bbd30e62799..fb3aafe76b52 100644 --- a/arch/arm64/kvm/guest.c +++ b/arch/arm64/kvm/guest.c @@ -28,19 +28,42 @@ #include "trace.h" +const char kvm_vm_stat_strings[][KVM_STATS_NAME_LEN] = { + "remote_tlb_flush", +}; +static_assert(sizeof(kvm_vm_stat_strings) == + VM_STAT_COUNT * KVM_STATS_NAME_LEN); + +const char kvm_vcpu_stat_strings[][KVM_STATS_NAME_LEN] = { + "halt_successful_poll", + "halt_attempted_poll", + "halt_poll_success_ns", + "halt_poll_fail_ns", + "halt_poll_invalid", + "halt_wakeup", + "hvc_exit_stat", + "wfe_exit_stat", + "wfi_exit_stat", + "mmio_exit_user", + "mmio_exit_kernel", + "exits", +}; +static_assert(sizeof(kvm_vcpu_stat_strings) == + VCPU_STAT_COUNT * KVM_STATS_NAME_LEN); + struct kvm_stats_debugfs_item debugfs_entries[] = { - VCPU_STAT("halt_successful_poll", halt_successful_poll), - VCPU_STAT("halt_attempted_poll", halt_attempted_poll), - VCPU_STAT("halt_poll_invalid", halt_poll_invalid), - VCPU_STAT("halt_wakeup", halt_wakeup), - VCPU_STAT("hvc_exit_stat", hvc_exit_stat), - VCPU_STAT("wfe_exit_stat", wfe_exit_stat), - VCPU_STAT("wfi_exit_stat", wfi_exit_stat), - VCPU_STAT("mmio_exit_user", mmio_exit_user), - VCPU_STAT("mmio_exit_kernel", mmio_exit_kernel), - VCPU_STAT("exits", exits), - VCPU_STAT("halt_poll_success_ns", halt_poll_success_ns), - VCPU_STAT("halt_poll_fail_ns", halt_poll_fail_ns), + VCPU_STAT(halt_successful_poll), + VCPU_STAT(halt_attempted_poll), + VCPU_STAT(halt_poll_invalid), + VCPU_STAT(halt_wakeup), + VCPU_STAT(hvc_exit_stat), + VCPU_STAT(wfe_exit_stat), + VCPU_STAT(wfi_exit_stat), + VCPU_STAT(mmio_exit_user), + VCPU_STAT(mmio_exit_kernel), + VCPU_STAT(exits), + VCPU_STAT(halt_poll_success_ns), + VCPU_STAT(halt_poll_fail_ns), { NULL } }; diff --git a/arch/mips/kvm/mips.c b/arch/mips/kvm/mips.c index 3d6a7f5827b1..8b9cbd9d6205 100644 --- a/arch/mips/kvm/mips.c +++ b/arch/mips/kvm/mips.c @@ -39,44 +39,92 @@ #define VECTORSPACING 0x100 /* for EI/VI mode */ #endif +const char kvm_vm_stat_strings[][KVM_STATS_NAME_LEN] = { + "remote_tlb_flush", +}; +static_assert(sizeof(kvm_vm_stat_strings) == + VM_STAT_COUNT * KVM_STATS_NAME_LEN); + +const char kvm_vcpu_stat_strings[][KVM_STATS_NAME_LEN] = { + "wait", + "cache", + "signal", + "interrupt", + "cop_unusable", + "tlbmod", + "tlbmiss_ld", + "tlbmiss_st", + "addrerr_st", + "addrerr_ld", + "syscall", + "resvd_inst", + "break_inst", + "trap_inst", + "msa_fpe", + "fpe", + "msa_disabled", + "flush_dcache", +#ifdef CONFIG_KVM_MIPS_VZ + "vz_gpsi", + "vz_gsfc", + "vz_hc", + "vz_grr", + "vz_gva", + "vz_ghfc", + "vz_gpa", + "vz_resvd", +#ifdef CONFIG_CPU_LOONGSON64 + "vz_cpucfg", +#endif +#endif + "halt_successful_poll", + "halt_attempted_poll", + "halt_poll_success_ns", + "halt_poll_fail_ns", + "halt_poll_invalid", + "halt_wakeup", +}; +static_assert(sizeof(kvm_vcpu_stat_strings) == + VCPU_STAT_COUNT * KVM_STATS_NAME_LEN); + struct kvm_stats_debugfs_item debugfs_entries[] = { - VCPU_STAT("wait", wait_exits), - VCPU_STAT("cache", cache_exits), - VCPU_STAT("signal", signal_exits), - VCPU_STAT("interrupt", int_exits), - VCPU_STAT("cop_unusable", cop_unusable_exits), - VCPU_STAT("tlbmod", tlbmod_exits), - VCPU_STAT("tlbmiss_ld", tlbmiss_ld_exits), - VCPU_STAT("tlbmiss_st", tlbmiss_st_exits), - VCPU_STAT("addrerr_st", addrerr_st_exits), - VCPU_STAT("addrerr_ld", addrerr_ld_exits), - VCPU_STAT("syscall", syscall_exits), - VCPU_STAT("resvd_inst", resvd_inst_exits), - VCPU_STAT("break_inst", break_inst_exits), - VCPU_STAT("trap_inst", trap_inst_exits), - VCPU_STAT("msa_fpe", msa_fpe_exits), - VCPU_STAT("fpe", fpe_exits), - VCPU_STAT("msa_disabled", msa_disabled_exits), - VCPU_STAT("flush_dcache", flush_dcache_exits), + VCPU_STAT(wait_exits), + VCPU_STAT(cache_exits), + VCPU_STAT(signal_exits), + VCPU_STAT(int_exits), + VCPU_STAT(cop_unusable_exits), + VCPU_STAT(tlbmod_exits), + VCPU_STAT(tlbmiss_ld_exits), + VCPU_STAT(tlbmiss_st_exits), + VCPU_STAT(addrerr_st_exits), + VCPU_STAT(addrerr_ld_exits), + VCPU_STAT(syscall_exits), + VCPU_STAT(resvd_inst_exits), + VCPU_STAT(break_inst_exits), + VCPU_STAT(trap_inst_exits), + VCPU_STAT(msa_fpe_exits), + VCPU_STAT(fpe_exits), + VCPU_STAT(msa_disabled_exits), + VCPU_STAT(flush_dcache_exits), #ifdef CONFIG_KVM_MIPS_VZ - VCPU_STAT("vz_gpsi", vz_gpsi_exits), - VCPU_STAT("vz_gsfc", vz_gsfc_exits), - VCPU_STAT("vz_hc", vz_hc_exits), - VCPU_STAT("vz_grr", vz_grr_exits), - VCPU_STAT("vz_gva", vz_gva_exits), - VCPU_STAT("vz_ghfc", vz_ghfc_exits), - VCPU_STAT("vz_gpa", vz_gpa_exits), - VCPU_STAT("vz_resvd", vz_resvd_exits), + VCPU_STAT(vz_gpsi_exits), + VCPU_STAT(vz_gsfc_exits), + VCPU_STAT(vz_hc_exits), + VCPU_STAT(vz_grr_exits), + VCPU_STAT(vz_gva_exits), + VCPU_STAT(vz_ghfc_exits), + VCPU_STAT(vz_gpa_exits), + VCPU_STAT(vz_resvd_exits), #ifdef CONFIG_CPU_LOONGSON64 - VCPU_STAT("vz_cpucfg", vz_cpucfg_exits), + VCPU_STAT(vz_cpucfg_exits), #endif #endif - VCPU_STAT("halt_successful_poll", halt_successful_poll), - VCPU_STAT("halt_attempted_poll", halt_attempted_poll), - VCPU_STAT("halt_poll_invalid", halt_poll_invalid), - VCPU_STAT("halt_wakeup", halt_wakeup), - VCPU_STAT("halt_poll_success_ns", halt_poll_success_ns), - VCPU_STAT("halt_poll_fail_ns", halt_poll_fail_ns), + VCPU_STAT(halt_successful_poll), + VCPU_STAT(halt_attempted_poll), + VCPU_STAT(halt_poll_invalid), + VCPU_STAT(halt_wakeup), + VCPU_STAT(halt_poll_success_ns), + VCPU_STAT(halt_poll_fail_ns), {NULL} }; diff --git a/arch/powerpc/kvm/book3s.c b/arch/powerpc/kvm/book3s.c index 44bf567b6589..22dd5a804468 100644 --- a/arch/powerpc/kvm/book3s.c +++ b/arch/powerpc/kvm/book3s.c @@ -36,38 +36,87 @@ #include "book3s.h" #include "trace.h" +const char kvm_vm_stat_strings[][KVM_STATS_NAME_LEN] = { + "remote_tlb_flush", + "largepages_2M", + "largepages_1G", +}; +static_assert(sizeof(kvm_vm_stat_strings) == + VM_STAT_COUNT * KVM_STATS_NAME_LEN); + +const char kvm_vcpu_stat_strings[][KVM_STATS_NAME_LEN] = { + "exits", + "mmio", + "sig", + "light", + "itlb_real_miss", + "itlb_virt_miss", + "dtlb_real_miss", + "dtlb_virt_miss", + "sysc", + "isi", + "dsi", + "inst_emu", + "dec", + "ext_intr", + "halt_poll_success_ns", + "halt_poll_fail_ns", + "halt_wait_ns", + "halt_successful_poll", + "halt_attempted_poll", + "halt_successful_wait", + "halt_poll_invalid", + "halt_wakeup", + "dbell", + "gdbell", + "ld", + "st", + "pf_storage", + "pf_instruc", + "sp_storage", + "sp_instruc", + "queue_intr", + "ld_slow", + "st_slow", + "pthru_all", + "pthru_host", + "pthru_bad_aff", +}; +static_assert(sizeof(kvm_vcpu_stat_strings) == + VCPU_STAT_COUNT * KVM_STATS_NAME_LEN); + /* #define EXIT_DEBUG */ struct kvm_stats_debugfs_item debugfs_entries[] = { - VCPU_STAT("exits", sum_exits), - VCPU_STAT("mmio", mmio_exits), - VCPU_STAT("sig", signal_exits), - VCPU_STAT("sysc", syscall_exits), - VCPU_STAT("inst_emu", emulated_inst_exits), - VCPU_STAT("dec", dec_exits), - VCPU_STAT("ext_intr", ext_intr_exits), - VCPU_STAT("queue_intr", queue_intr), - VCPU_STAT("halt_poll_success_ns", halt_poll_success_ns), - VCPU_STAT("halt_poll_fail_ns", halt_poll_fail_ns), - VCPU_STAT("halt_wait_ns", halt_wait_ns), - VCPU_STAT("halt_successful_poll", halt_successful_poll), - VCPU_STAT("halt_attempted_poll", halt_attempted_poll), - VCPU_STAT("halt_successful_wait", halt_successful_wait), - VCPU_STAT("halt_poll_invalid", halt_poll_invalid), - VCPU_STAT("halt_wakeup", halt_wakeup), - VCPU_STAT("pf_storage", pf_storage), - VCPU_STAT("sp_storage", sp_storage), - VCPU_STAT("pf_instruc", pf_instruc), - VCPU_STAT("sp_instruc", sp_instruc), - VCPU_STAT("ld", ld), - VCPU_STAT("ld_slow", ld_slow), - VCPU_STAT("st", st), - VCPU_STAT("st_slow", st_slow), - VCPU_STAT("pthru_all", pthru_all), - VCPU_STAT("pthru_host", pthru_host), - VCPU_STAT("pthru_bad_aff", pthru_bad_aff), - VM_STAT("largepages_2M", num_2M_pages, .mode = 0444), - VM_STAT("largepages_1G", num_1G_pages, .mode = 0444), + VCPU_STAT(sum_exits), + VCPU_STAT(mmio_exits), + VCPU_STAT(signal_exits), + VCPU_STAT(syscall_exits), + VCPU_STAT(emulated_inst_exits), + VCPU_STAT(dec_exits), + VCPU_STAT(ext_intr_exits), + VCPU_STAT(queue_intr), + VCPU_STAT(halt_poll_success_ns), + VCPU_STAT(halt_poll_fail_ns), + VCPU_STAT(halt_wait_ns), + VCPU_STAT(halt_successful_poll), + VCPU_STAT(halt_attempted_poll), + VCPU_STAT(halt_successful_wait), + VCPU_STAT(halt_poll_invalid), + VCPU_STAT(halt_wakeup), + VCPU_STAT(pf_storage), + VCPU_STAT(sp_storage), + VCPU_STAT(pf_instruc), + VCPU_STAT(sp_instruc), + VCPU_STAT(ld), + VCPU_STAT(ld_slow), + VCPU_STAT(st), + VCPU_STAT(st_slow), + VCPU_STAT(pthru_all), + VCPU_STAT(pthru_host), + VCPU_STAT(pthru_bad_aff), + VM_STAT(num_2M_pages, .mode = 0444), + VM_STAT(num_1G_pages, .mode = 0444), { NULL } }; diff --git a/arch/powerpc/kvm/booke.c b/arch/powerpc/kvm/booke.c index f38ae3e54b37..faa830f8178b 100644 --- a/arch/powerpc/kvm/booke.c +++ b/arch/powerpc/kvm/booke.c @@ -35,28 +35,70 @@ unsigned long kvmppc_booke_handlers; +const char kvm_vm_stat_strings[][KVM_STATS_NAME_LEN] = { + "remote_tlb_flush", + "largepages_2M", + "largepages_1G", +}; +static_assert(sizeof(kvm_vm_stat_strings) == + VM_STAT_COUNT * KVM_STATS_NAME_LEN); + +const char kvm_vcpu_stat_strings[][KVM_STATS_NAME_LEN] = { + "exits", + "mmio", + "sig", + "light", + "itlb_real_miss", + "itlb_virt_miss", + "dtlb_real_miss", + "dtlb_virt_miss", + "sysc", + "isi", + "dsi", + "inst_emu", + "dec", + "ext_intr", + "halt_poll_success_ns", + "halt_poll_fail_ns", + "halt_wait_ns", + "halt_successful_poll", + "halt_attempted_poll", + "halt_successful_wait", + "halt_poll_invalid", + "halt_wakeup", + "dbell", + "gdbell", + "ld", + "st", + "pthru_all", + "pthru_host", + "pthru_bad_aff", +}; +static_assert(sizeof(kvm_vcpu_stat_strings) == + VCPU_STAT_COUNT * KVM_STATS_NAME_LEN); + struct kvm_stats_debugfs_item debugfs_entries[] = { - VCPU_STAT("mmio", mmio_exits), - VCPU_STAT("sig", signal_exits), - VCPU_STAT("itlb_r", itlb_real_miss_exits), - VCPU_STAT("itlb_v", itlb_virt_miss_exits), - VCPU_STAT("dtlb_r", dtlb_real_miss_exits), - VCPU_STAT("dtlb_v", dtlb_virt_miss_exits), - VCPU_STAT("sysc", syscall_exits), - VCPU_STAT("isi", isi_exits), - VCPU_STAT("dsi", dsi_exits), - VCPU_STAT("inst_emu", emulated_inst_exits), - VCPU_STAT("dec", dec_exits), - VCPU_STAT("ext_intr", ext_intr_exits), - VCPU_STAT("halt_successful_poll", halt_successful_poll), - VCPU_STAT("halt_attempted_poll", halt_attempted_poll), - VCPU_STAT("halt_poll_invalid", halt_poll_invalid), - VCPU_STAT("halt_wakeup", halt_wakeup), - VCPU_STAT("doorbell", dbell_exits), - VCPU_STAT("guest doorbell", gdbell_exits), - VCPU_STAT("halt_poll_success_ns", halt_poll_success_ns), - VCPU_STAT("halt_poll_fail_ns", halt_poll_fail_ns), - VM_STAT("remote_tlb_flush", remote_tlb_flush), + VCPU_STAT(mmio_exits), + VCPU_STAT(signal_exits), + VCPU_STAT(itlb_real_miss_exits), + VCPU_STAT(itlb_virt_miss_exits), + VCPU_STAT(dtlb_real_miss_exits), + VCPU_STAT(dtlb_virt_miss_exits), + VCPU_STAT(syscall_exits), + VCPU_STAT(isi_exits), + VCPU_STAT(dsi_exits), + VCPU_STAT(emulated_inst_exits), + VCPU_STAT(dec_exits), + VCPU_STAT(ext_intr_exits), + VCPU_STAT(halt_successful_poll), + VCPU_STAT(halt_attempted_poll), + VCPU_STAT(halt_poll_invalid), + VCPU_STAT(halt_wakeup), + VCPU_STAT(dbell_exits), + VCPU_STAT(gdbell_exits), + VCPU_STAT(halt_poll_success_ns), + VCPU_STAT(halt_poll_fail_ns), + VM_STAT(remote_tlb_flush), { NULL } }; diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c index dbafd057ca6a..cefec8c1e87a 100644 --- a/arch/s390/kvm/kvm-s390.c +++ b/arch/s390/kvm/kvm-s390.c @@ -57,110 +57,224 @@ #define VCPU_IRQS_MAX_BUF (sizeof(struct kvm_s390_irq) * \ (KVM_MAX_VCPUS + LOCAL_IRQS)) +const char kvm_vm_stat_strings[][KVM_STATS_NAME_LEN] = { + "inject_io", + "inject_float_mchk", + "inject_pfault_done", + "inject_service_signal", + "inject_virtio", + "remote_tlb_flush", +}; +static_assert(sizeof(kvm_vm_stat_strings) == + VM_STAT_COUNT * KVM_STATS_NAME_LEN); + +const char kvm_vcpu_stat_strings[][KVM_STATS_NAME_LEN] = { + "userspace_handled", + "exit_null", + "exit_external_request", + "exit_io_request", + "exit_external_interrupt", + "exit_stop_request", + "exit_validity", + "exit_instruction", + "exit_pei", + "halt_successful_poll", + "halt_attempted_poll", + "halt_poll_invalid", + "halt_no_poll_steal", + "halt_wakeup", + "halt_poll_success_ns", + "halt_poll_fail_ns", + "instruction_lctlg", + "instruction_lctl", + "instruction_stctl", + "instruction_stctg", + "exit_program_interruption", + "exit_instr_and_program_int", + "exit_operation_exception", + "deliver_ckc", + "deliver_cputm", + "deliver_external_call", + "deliver_emergency_signal", + "deliver_service_signal", + "deliver_virtio", + "deliver_stop_signal", + "deliver_prefix_signal", + "deliver_restart_signal", + "deliver_program", + "deliver_io", + "deliver_machine_check", + "exit_wait_state", + "inject_ckc", + "inject_cputm", + "inject_external_call", + "inject_emergency_signal", + "inject_mchk", + "inject_pfault_init", + "inject_program", + "inject_restart", + "inject_set_prefix", + "inject_stop_signal", + "instruction_epsw", + "instruction_gs", + "instruction_io_other", + "instruction_lpsw", + "instruction_lpswe", + "instruction_pfmf", + "instruction_ptff", + "instruction_sck", + "instruction_sckpf", + "instruction_stidp", + "instruction_spx", + "instruction_stpx", + "instruction_stap", + "instruction_iske", + "instruction_ri", + "instruction_rrbe", + "instruction_sske", + "instruction_ipte_interlock", + "instruction_stsi", + "instruction_stfl", + "instruction_tb", + "instruction_tpi", + "instruction_tprot", + "instruction_tsch", + "instruction_sie", + "instruction_essa", + "instruction_sthyi", + "instruction_sigp_sense", + "instruction_sigp_sense_running", + "instruction_sigp_external_call", + "instruction_sigp_emergency", + "instruction_sigp_cond_emergency", + "instruction_sigp_start", + "instruction_sigp_stop", + "instruction_sigp_stop_store_status", + "instruction_sigp_store_status", + "instruction_sigp_store_adtl_status", + "instruction_sigp_set_arch", + "instruction_sigp_set_prefix", + "instruction_sigp_restart", + "instruction_sigp_init_cpu_reset", + "instruction_sigp_cpu_reset", + "instruction_sigp_unknown", + "instruction_diag_10", + "instruction_diag_44", + "instruction_diag_9c", + "diag_9c_ignored", + "instruction_diag_258", + "instruction_diag_308", + "instruction_diag_500", + "instruction_diag_other", + "pfault_sync", +}; +static_assert(sizeof(kvm_vcpu_stat_strings) == + VCPU_STAT_COUNT * KVM_STATS_NAME_LEN); + struct kvm_stats_debugfs_item debugfs_entries[] = { - VCPU_STAT("userspace_handled", exit_userspace), - VCPU_STAT("exit_null", exit_null), - VCPU_STAT("pfault_sync", pfault_sync), - VCPU_STAT("exit_validity", exit_validity), - VCPU_STAT("exit_stop_request", exit_stop_request), - VCPU_STAT("exit_external_request", exit_external_request), - VCPU_STAT("exit_io_request", exit_io_request), - VCPU_STAT("exit_external_interrupt", exit_external_interrupt), - VCPU_STAT("exit_instruction", exit_instruction), - VCPU_STAT("exit_pei", exit_pei), - VCPU_STAT("exit_program_interruption", exit_program_interruption), - VCPU_STAT("exit_instr_and_program_int", exit_instr_and_program), - VCPU_STAT("exit_operation_exception", exit_operation_exception), - VCPU_STAT("halt_successful_poll", halt_successful_poll), - VCPU_STAT("halt_attempted_poll", halt_attempted_poll), - VCPU_STAT("halt_poll_invalid", halt_poll_invalid), - VCPU_STAT("halt_no_poll_steal", halt_no_poll_steal), - VCPU_STAT("halt_wakeup", halt_wakeup), - VCPU_STAT("halt_poll_success_ns", halt_poll_success_ns), - VCPU_STAT("halt_poll_fail_ns", halt_poll_fail_ns), - VCPU_STAT("instruction_lctlg", instruction_lctlg), - VCPU_STAT("instruction_lctl", instruction_lctl), - VCPU_STAT("instruction_stctl", instruction_stctl), - VCPU_STAT("instruction_stctg", instruction_stctg), - VCPU_STAT("deliver_ckc", deliver_ckc), - VCPU_STAT("deliver_cputm", deliver_cputm), - VCPU_STAT("deliver_emergency_signal", deliver_emergency_signal), - VCPU_STAT("deliver_external_call", deliver_external_call), - VCPU_STAT("deliver_service_signal", deliver_service_signal), - VCPU_STAT("deliver_virtio", deliver_virtio), - VCPU_STAT("deliver_stop_signal", deliver_stop_signal), - VCPU_STAT("deliver_prefix_signal", deliver_prefix_signal), - VCPU_STAT("deliver_restart_signal", deliver_restart_signal), - VCPU_STAT("deliver_program", deliver_program), - VCPU_STAT("deliver_io", deliver_io), - VCPU_STAT("deliver_machine_check", deliver_machine_check), - VCPU_STAT("exit_wait_state", exit_wait_state), - VCPU_STAT("inject_ckc", inject_ckc), - VCPU_STAT("inject_cputm", inject_cputm), - VCPU_STAT("inject_external_call", inject_external_call), - VM_STAT("inject_float_mchk", inject_float_mchk), - VCPU_STAT("inject_emergency_signal", inject_emergency_signal), - VM_STAT("inject_io", inject_io), - VCPU_STAT("inject_mchk", inject_mchk), - VM_STAT("inject_pfault_done", inject_pfault_done), - VCPU_STAT("inject_program", inject_program), - VCPU_STAT("inject_restart", inject_restart), - VM_STAT("inject_service_signal", inject_service_signal), - VCPU_STAT("inject_set_prefix", inject_set_prefix), - VCPU_STAT("inject_stop_signal", inject_stop_signal), - VCPU_STAT("inject_pfault_init", inject_pfault_init), - VM_STAT("inject_virtio", inject_virtio), - VCPU_STAT("instruction_epsw", instruction_epsw), - VCPU_STAT("instruction_gs", instruction_gs), - VCPU_STAT("instruction_io_other", instruction_io_other), - VCPU_STAT("instruction_lpsw", instruction_lpsw), - VCPU_STAT("instruction_lpswe", instruction_lpswe), - VCPU_STAT("instruction_pfmf", instruction_pfmf), - VCPU_STAT("instruction_ptff", instruction_ptff), - VCPU_STAT("instruction_stidp", instruction_stidp), - VCPU_STAT("instruction_sck", instruction_sck), - VCPU_STAT("instruction_sckpf", instruction_sckpf), - VCPU_STAT("instruction_spx", instruction_spx), - VCPU_STAT("instruction_stpx", instruction_stpx), - VCPU_STAT("instruction_stap", instruction_stap), - VCPU_STAT("instruction_iske", instruction_iske), - VCPU_STAT("instruction_ri", instruction_ri), - VCPU_STAT("instruction_rrbe", instruction_rrbe), - VCPU_STAT("instruction_sske", instruction_sske), - VCPU_STAT("instruction_ipte_interlock", instruction_ipte_interlock), - VCPU_STAT("instruction_essa", instruction_essa), - VCPU_STAT("instruction_stsi", instruction_stsi), - VCPU_STAT("instruction_stfl", instruction_stfl), - VCPU_STAT("instruction_tb", instruction_tb), - VCPU_STAT("instruction_tpi", instruction_tpi), - VCPU_STAT("instruction_tprot", instruction_tprot), - VCPU_STAT("instruction_tsch", instruction_tsch), - VCPU_STAT("instruction_sthyi", instruction_sthyi), - VCPU_STAT("instruction_sie", instruction_sie), - VCPU_STAT("instruction_sigp_sense", instruction_sigp_sense), - VCPU_STAT("instruction_sigp_sense_running", instruction_sigp_sense_running), - VCPU_STAT("instruction_sigp_external_call", instruction_sigp_external_call), - VCPU_STAT("instruction_sigp_emergency", instruction_sigp_emergency), - VCPU_STAT("instruction_sigp_cond_emergency", instruction_sigp_cond_emergency), - VCPU_STAT("instruction_sigp_start", instruction_sigp_start), - VCPU_STAT("instruction_sigp_stop", instruction_sigp_stop), - VCPU_STAT("instruction_sigp_stop_store_status", instruction_sigp_stop_store_status), - VCPU_STAT("instruction_sigp_store_status", instruction_sigp_store_status), - VCPU_STAT("instruction_sigp_store_adtl_status", instruction_sigp_store_adtl_status), - VCPU_STAT("instruction_sigp_set_arch", instruction_sigp_arch), - VCPU_STAT("instruction_sigp_set_prefix", instruction_sigp_prefix), - VCPU_STAT("instruction_sigp_restart", instruction_sigp_restart), - VCPU_STAT("instruction_sigp_cpu_reset", instruction_sigp_cpu_reset), - VCPU_STAT("instruction_sigp_init_cpu_reset", instruction_sigp_init_cpu_reset), - VCPU_STAT("instruction_sigp_unknown", instruction_sigp_unknown), - VCPU_STAT("instruction_diag_10", diagnose_10), - VCPU_STAT("instruction_diag_44", diagnose_44), - VCPU_STAT("instruction_diag_9c", diagnose_9c), - VCPU_STAT("diag_9c_ignored", diagnose_9c_ignored), - VCPU_STAT("instruction_diag_258", diagnose_258), - VCPU_STAT("instruction_diag_308", diagnose_308), - VCPU_STAT("instruction_diag_500", diagnose_500), - VCPU_STAT("instruction_diag_other", diagnose_other), + VCPU_STAT(exit_userspace), + VCPU_STAT(exit_null), + VCPU_STAT(pfault_sync), + VCPU_STAT(exit_validity), + VCPU_STAT(exit_stop_request), + VCPU_STAT(exit_external_request), + VCPU_STAT(exit_io_request), + VCPU_STAT(exit_external_interrupt), + VCPU_STAT(exit_instruction), + VCPU_STAT(exit_pei), + VCPU_STAT(exit_program_interruption), + VCPU_STAT(exit_instr_and_program), + VCPU_STAT(exit_operation_exception), + VCPU_STAT(halt_successful_poll), + VCPU_STAT(halt_attempted_poll), + VCPU_STAT(halt_poll_invalid), + VCPU_STAT(halt_no_poll_steal), + VCPU_STAT(halt_wakeup), + VCPU_STAT(halt_poll_success_ns), + VCPU_STAT(halt_poll_fail_ns), + VCPU_STAT(instruction_lctlg), + VCPU_STAT(instruction_lctl), + VCPU_STAT(instruction_stctl), + VCPU_STAT(instruction_stctg), + VCPU_STAT(deliver_ckc), + VCPU_STAT(deliver_cputm), + VCPU_STAT(deliver_emergency_signal), + VCPU_STAT(deliver_external_call), + VCPU_STAT(deliver_service_signal), + VCPU_STAT(deliver_virtio), + VCPU_STAT(deliver_stop_signal), + VCPU_STAT(deliver_prefix_signal), + VCPU_STAT(deliver_restart_signal), + VCPU_STAT(deliver_program), + VCPU_STAT(deliver_io), + VCPU_STAT(deliver_machine_check), + VCPU_STAT(exit_wait_state), + VCPU_STAT(inject_ckc), + VCPU_STAT(inject_cputm), + VCPU_STAT(inject_external_call), + VM_STAT(inject_float_mchk), + VCPU_STAT(inject_emergency_signal), + VM_STAT(inject_io), + VCPU_STAT(inject_mchk), + VM_STAT(inject_pfault_done), + VCPU_STAT(inject_program), + VCPU_STAT(inject_restart), + VM_STAT(inject_service_signal), + VCPU_STAT(inject_set_prefix), + VCPU_STAT(inject_stop_signal), + VCPU_STAT(inject_pfault_init), + VM_STAT(inject_virtio), + VCPU_STAT(instruction_epsw), + VCPU_STAT(instruction_gs), + VCPU_STAT(instruction_io_other), + VCPU_STAT(instruction_lpsw), + VCPU_STAT(instruction_lpswe), + VCPU_STAT(instruction_pfmf), + VCPU_STAT(instruction_ptff), + VCPU_STAT(instruction_stidp), + VCPU_STAT(instruction_sck), + VCPU_STAT(instruction_sckpf), + VCPU_STAT(instruction_spx), + VCPU_STAT(instruction_stpx), + VCPU_STAT(instruction_stap), + VCPU_STAT(instruction_iske), + VCPU_STAT(instruction_ri), + VCPU_STAT(instruction_rrbe), + VCPU_STAT(instruction_sske), + VCPU_STAT(instruction_ipte_interlock), + VCPU_STAT(instruction_essa), + VCPU_STAT(instruction_stsi), + VCPU_STAT(instruction_stfl), + VCPU_STAT(instruction_tb), + VCPU_STAT(instruction_tpi), + VCPU_STAT(instruction_tprot), + VCPU_STAT(instruction_tsch), + VCPU_STAT(instruction_sthyi), + VCPU_STAT(instruction_sie), + VCPU_STAT(instruction_sigp_sense), + VCPU_STAT(instruction_sigp_sense_running), + VCPU_STAT(instruction_sigp_external_call), + VCPU_STAT(instruction_sigp_emergency), + VCPU_STAT(instruction_sigp_cond_emergency), + VCPU_STAT(instruction_sigp_start), + VCPU_STAT(instruction_sigp_stop), + VCPU_STAT(instruction_sigp_stop_store_status), + VCPU_STAT(instruction_sigp_store_status), + VCPU_STAT(instruction_sigp_store_adtl_status), + VCPU_STAT(instruction_sigp_arch), + VCPU_STAT(instruction_sigp_prefix), + VCPU_STAT(instruction_sigp_restart), + VCPU_STAT(instruction_sigp_cpu_reset), + VCPU_STAT(instruction_sigp_init_cpu_reset), + VCPU_STAT(instruction_sigp_unknown), + VCPU_STAT(diagnose_10), + VCPU_STAT(diagnose_44), + VCPU_STAT(diagnose_9c), + VCPU_STAT(diagnose_9c_ignored), + VCPU_STAT(diagnose_258), + VCPU_STAT(diagnose_308), + VCPU_STAT(diagnose_500), + VCPU_STAT(diagnose_other), { NULL } }; diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c index 46b0e52671bb..e0b02a29c760 100644 --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c @@ -216,46 +216,95 @@ EXPORT_SYMBOL_GPL(host_xss); u64 __read_mostly supported_xss; EXPORT_SYMBOL_GPL(supported_xss); +const char kvm_vm_stat_strings[][KVM_STATS_NAME_LEN] = { + "mmu_shadow_zapped", + "mmu_pte_write", + "mmu_pde_zapped", + "mmu_flooded", + "mmu_recycled", + "mmu_cache_miss", + "mmu_unsync", + "remote_tlb_flush", + "largepages", + "nx_largepages_splitted", + "max_mmu_page_hash_collisions", +}; +static_assert(sizeof(kvm_vm_stat_strings) == + VM_STAT_COUNT * KVM_STATS_NAME_LEN); + +const char kvm_vcpu_stat_strings[][KVM_STATS_NAME_LEN] = { + "pf_fixed", + "pf_guest", + "tlb_flush", + "invlpg", + "exits", + "io_exits", + "mmio_exits", + "signal_exits", + "irq_window", + "nmi_window", + "l1d_flush", + "halt_exits", + "halt_successful_poll", + "halt_attempted_poll", + "halt_poll_invalid", + "halt_wakeup", + "request_irq", + "irq_exits", + "host_state_reload", + "fpu_reload", + "insn_emulation", + "insn_emulation_fail", + "hypercalls", + "irq_injections", + "nmi_injections", + "req_event", + "halt_poll_success_ns", + "halt_poll_fail_ns", +}; +static_assert(sizeof(kvm_vcpu_stat_strings) == + VCPU_STAT_COUNT * KVM_STATS_NAME_LEN); + struct kvm_stats_debugfs_item debugfs_entries[] = { - VCPU_STAT("pf_fixed", pf_fixed), - VCPU_STAT("pf_guest", pf_guest), - VCPU_STAT("tlb_flush", tlb_flush), - VCPU_STAT("invlpg", invlpg), - VCPU_STAT("exits", exits), - VCPU_STAT("io_exits", io_exits), - VCPU_STAT("mmio_exits", mmio_exits), - VCPU_STAT("signal_exits", signal_exits), - VCPU_STAT("irq_window", irq_window_exits), - VCPU_STAT("nmi_window", nmi_window_exits), - VCPU_STAT("halt_exits", halt_exits), - VCPU_STAT("halt_successful_poll", halt_successful_poll), - VCPU_STAT("halt_attempted_poll", halt_attempted_poll), - VCPU_STAT("halt_poll_invalid", halt_poll_invalid), - VCPU_STAT("halt_wakeup", halt_wakeup), - VCPU_STAT("hypercalls", hypercalls), - VCPU_STAT("request_irq", request_irq_exits), - VCPU_STAT("irq_exits", irq_exits), - VCPU_STAT("host_state_reload", host_state_reload), - VCPU_STAT("fpu_reload", fpu_reload), - VCPU_STAT("insn_emulation", insn_emulation), - VCPU_STAT("insn_emulation_fail", insn_emulation_fail), - VCPU_STAT("irq_injections", irq_injections), - VCPU_STAT("nmi_injections", nmi_injections), - VCPU_STAT("req_event", req_event), - VCPU_STAT("l1d_flush", l1d_flush), - VCPU_STAT("halt_poll_success_ns", halt_poll_success_ns), - VCPU_STAT("halt_poll_fail_ns", halt_poll_fail_ns), - VM_STAT("mmu_shadow_zapped", mmu_shadow_zapped), - VM_STAT("mmu_pte_write", mmu_pte_write), - VM_STAT("mmu_pde_zapped", mmu_pde_zapped), - VM_STAT("mmu_flooded", mmu_flooded), - VM_STAT("mmu_recycled", mmu_recycled), - VM_STAT("mmu_cache_miss", mmu_cache_miss), - VM_STAT("mmu_unsync", mmu_unsync), - VM_STAT("remote_tlb_flush", remote_tlb_flush), - VM_STAT("largepages", lpages, .mode = 0444), - VM_STAT("nx_largepages_splitted", nx_lpage_splits, .mode = 0444), - VM_STAT("max_mmu_page_hash_collisions", max_mmu_page_hash_collisions), + VCPU_STAT(pf_fixed), + VCPU_STAT(pf_guest), + VCPU_STAT(tlb_flush), + VCPU_STAT(invlpg), + VCPU_STAT(exits), + VCPU_STAT(io_exits), + VCPU_STAT(mmio_exits), + VCPU_STAT(signal_exits), + VCPU_STAT(irq_window_exits), + VCPU_STAT(nmi_window_exits), + VCPU_STAT(halt_exits), + VCPU_STAT(halt_successful_poll), + VCPU_STAT(halt_attempted_poll), + VCPU_STAT(halt_poll_invalid), + VCPU_STAT(halt_wakeup), + VCPU_STAT(hypercalls), + VCPU_STAT(request_irq_exits), + VCPU_STAT(irq_exits), + VCPU_STAT(host_state_reload), + VCPU_STAT(fpu_reload), + VCPU_STAT(insn_emulation), + VCPU_STAT(insn_emulation_fail), + VCPU_STAT(irq_injections), + VCPU_STAT(nmi_injections), + VCPU_STAT(req_event), + VCPU_STAT(l1d_flush), + VCPU_STAT(halt_poll_success_ns), + VCPU_STAT(halt_poll_fail_ns), + VM_STAT(mmu_shadow_zapped), + VM_STAT(mmu_pte_write), + VM_STAT(mmu_pde_zapped), + VM_STAT(mmu_flooded), + VM_STAT(mmu_recycled), + VM_STAT(mmu_cache_miss), + VM_STAT(mmu_unsync), + VM_STAT(remote_tlb_flush), + VM_STAT(lpages, .mode = 0444), + VM_STAT(nx_lpage_splits, .mode = 0444), + VM_STAT(max_mmu_page_hash_collisions), { NULL } }; diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h index 1b65e7204344..1ea297458306 100644 --- a/include/linux/kvm_host.h +++ b/include/linux/kvm_host.h @@ -1162,6 +1162,18 @@ static inline bool kvm_is_error_gpa(struct kvm *kvm, gpa_t gpa) return kvm_is_error_hva(hva); } +#define VM_STAT_COUNT (sizeof(struct kvm_vm_stat)/sizeof(ulong)) +#define VCPU_STAT_COUNT (sizeof(struct kvm_vcpu_stat)/sizeof(u64)) +#define KVM_STATS_NAME_LEN 32 + +/* Make sure it is synced with fields in struct kvm_vm_stat. */ +extern const char kvm_vm_stat_strings[][KVM_STATS_NAME_LEN]; +/* Make sure it is synced with fields in struct kvm_vcpu_stat. */ +extern const char kvm_vcpu_stat_strings[][KVM_STATS_NAME_LEN]; + +#define VM_STAT_NAME(id) (kvm_vm_stat_strings[id]) +#define VCPU_STAT_NAME(id) (kvm_vcpu_stat_strings[id]) + enum kvm_stat_kind { KVM_STAT_VM, KVM_STAT_VCPU, @@ -1182,10 +1194,21 @@ struct kvm_stats_debugfs_item { #define KVM_DBGFS_GET_MODE(dbgfs_item) \ ((dbgfs_item)->mode ? (dbgfs_item)->mode : 0644) -#define VM_STAT(n, x, ...) \ - { n, offsetof(struct kvm, stat.x), KVM_STAT_VM, ## __VA_ARGS__ } -#define VCPU_STAT(n, x, ...) \ - { n, offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU, ## __VA_ARGS__ } +#define VM_STAT(x, ...) \ + { \ + VM_STAT_NAME(offsetof(struct kvm_vm_stat, x)/sizeof(ulong)), \ + offsetof(struct kvm, stat.x), \ + KVM_STAT_VM, \ + ## __VA_ARGS__ \ + } + +#define VCPU_STAT(x, ...) \ + { \ + VCPU_STAT_NAME(offsetof(struct kvm_vcpu_stat, x)/sizeof(u64)), \ + offsetof(struct kvm_vcpu, stat.x), \ + KVM_STAT_VCPU, \ + ## __VA_ARGS__ \ + } extern struct kvm_stats_debugfs_item debugfs_entries[]; extern struct dentry *kvm_debugfs_dir; From patchwork Wed Mar 10 00:30:22 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jing Zhang X-Patchwork-Id: 12126779 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-26.3 required=3.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT,USER_IN_DEF_DKIM_WL autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id C4344C43142 for ; Wed, 10 Mar 2021 00:31:47 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 8FF8B64F55 for ; Wed, 10 Mar 2021 00:31:47 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231429AbhCJAbR (ORCPT ); Tue, 9 Mar 2021 19:31:17 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:47992 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231396AbhCJAap (ORCPT ); Tue, 9 Mar 2021 19:30:45 -0500 Received: from mail-oi1-x24a.google.com (mail-oi1-x24a.google.com [IPv6:2607:f8b0:4864:20::24a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id F06F7C061762 for ; Tue, 9 Mar 2021 16:30:44 -0800 (PST) Received: by mail-oi1-x24a.google.com with SMTP id m19so7433262oiw.19 for ; Tue, 09 Mar 2021 16:30:44 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=yK9iTxY4SPYbSSesaQoUo2q8UFyrEaYR8MwQ1IPWqYo=; b=rfPkmtLrdMMpGWrKUsoZrxSRse5qNsSvVuH/ikfb+KgmDu+7xZIAfNt3HpkpEZ97Az zarNFgesGm3PBWe9L+mczl93U732Ye93g+WDGdbRfWuWXNyzVXqWHfiY/cIbjAbmSvnn qj8XR13VP7p0Bd1mXfnPXjd8hkcW7rWCwxqMvFG5ZgpsriYl31doDwniGQN2KAZPgHhW vxlB4aNj0kDNyTlpdssb2f1iJVPLzBRV0BhxBl6fV30cgxVs3P6ZTphJCo9AJxEKWhqT q3oeEXUht4UienfFOrO/VUVMSHSZgd4O88fKVNlhlh4oqoZF6cpqmPjFW81N8l5UmUnd UQwQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=yK9iTxY4SPYbSSesaQoUo2q8UFyrEaYR8MwQ1IPWqYo=; b=Up+f6rtLSA+r5ICOjGLYHpTxG3nYkCP1Pr4uV6LBgMEOIaB7Wuu5OKlzqza3ji92/C 0Zb3GEkzVCv7YeqHfu5mjNiQ37b7AJi5VG4oxoTmg/HRYSd95yov02kdBlzfAu6VjZHV O0sXGxngnMICIlK0j2lgGExpJCu/QrSfpuq19xiyhTTD68vuPgJlBJpgSF3ecHKCW7Cc Dhd/67BiNbvUByJiM9FiZGPsE+T6eNTX6/amxSupOyr6e9yK38aRvzFQzUup5PhMdS8I YPdNGjVn2Mh/u+xE7I2RnHwRR3l6kTOY4bdbB/PcjPc9LAOYT+5e3KuZKvJaxVCU8h43 i+vw== X-Gm-Message-State: AOAM532Sr1SM4v3/cW3OabJVX6+svysQRmp2hob2+2Gw2xvefUEDTv1O BMrPmP1NYNzZBeMantDOAW4ISIhJvKNAYCY98kNsrxZAPCiUlMGGoRrD2SyfM4Yju3t+2VLtKOK T7mv/CW2PeycqGOom6kBoEyadhWHcbHHwBNBTgVY2WVLx95HkvRf4eCtrqHYdu57EPGFHoPg= X-Google-Smtp-Source: ABdhPJzrzyemlWc6uAKn+Q/tSsI1AAuaRP7yS778qtLKkneKHFCrPC7TFQ37cF1P4tNWDHS1FdAWFVDzeqEE0qejsg== X-Received: from jingzhangos.c.googlers.com ([fda3:e722:ac3:10:2b:ff92:c0a8:513]) (user=jingzhangos job=sendgmr) by 2002:a9d:1c7:: with SMTP id e65mr592890ote.259.1615336244140; Tue, 09 Mar 2021 16:30:44 -0800 (PST) Date: Wed, 10 Mar 2021 00:30:22 +0000 In-Reply-To: <20210310003024.2026253-1-jingzhangos@google.com> Message-Id: <20210310003024.2026253-3-jingzhangos@google.com> Mime-Version: 1.0 References: <20210310003024.2026253-1-jingzhangos@google.com> X-Mailer: git-send-email 2.30.1.766.gb4fecdf3b7-goog Subject: [RFC PATCH 2/4] KVM: stats: Define APIs for aggregated stats retrieval in binary format From: Jing Zhang To: KVM , KVM ARM , Linux MIPS , KVM PPC , Linux S390 , Linux kselftest , Paolo Bonzini , Marc Zyngier , James Morse , Julien Thierry , Suzuki K Poulose , Will Deacon , Huacai Chen , Aleksandar Markovic , Thomas Bogendoerfer , Paul Mackerras , Christian Borntraeger , Janosch Frank , David Hildenbrand , Cornelia Huck , Claudio Imbrenda , Sean Christopherson , Vitaly Kuznetsov , Jim Mattson , Peter Shier , Oliver Upton , David Rientjes , Emanuele Giuseppe Esposito Cc: Jing Zhang Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Define ioctl commands for VM/vCPU aggregated statistics data retrieval in binary format and update corresponding API documentation. The capability and ioctl are not enabled for now. No functional change intended. Signed-off-by: Jing Zhang --- Documentation/virt/kvm/api.rst | 79 ++++++++++++++++++++++++++++++++++ include/linux/kvm_host.h | 1 - include/uapi/linux/kvm.h | 60 ++++++++++++++++++++++++++ 3 files changed, 139 insertions(+), 1 deletion(-) diff --git a/Documentation/virt/kvm/api.rst b/Documentation/virt/kvm/api.rst index 1a2b5210cdbf..aa4b5270c966 100644 --- a/Documentation/virt/kvm/api.rst +++ b/Documentation/virt/kvm/api.rst @@ -4938,6 +4938,76 @@ see KVM_XEN_VCPU_SET_ATTR above. The KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_ADJUST type may not be used with the KVM_XEN_VCPU_GET_ATTR ioctl. +4.131 KVM_STATS_GET_INFO +------------------------ + +:Capability: KVM_CAP_STATS_BINARY_FORM +:Architectures: all +:Type: vm ioctl, vcpu ioctl +:Parameters: struct kvm_stats_info (out) +:Returns: 0 on success, < 0 on error + +:: + + struct kvm_stats_info { + __u32 num_stats; + }; + +This ioctl is used to get the information about VM or vCPU statistics data. +The number of statistics data would be returned in field num_stats in +struct kvm_stats_info. This ioctl only needs to be called once on running +VMs on the same architecture. + +4.132 KVM_STATS_GET_NAMES +------------------------- + +:Capability: KVM_CAP_STATS_BINARY_FORM +:Architectures: all +:Type: vm ioctl, vcpu ioctl +:Parameters: struct kvm_stats_names (in/out) +:Returns: 0 on success, < 0 on error + +:: + + #define KVM_STATS_NAME_LEN 32 + struct kvm_stats_names { + __u32 size; + __u8 names[0]; + }; + +This ioctl is used to get the string names of all the statistics data for VM +or vCPU. Users must use KVM_STATS_GET_INFO to find the number of statistics. +They must allocate a buffer of the size num_stats * KVM_STATS_NAME_LEN +immediately following struct kvm_stats_names. The size field of kvm_stats_name +must contain the buffer size as an input. +The buffer can be treated like a string array, each name string is null-padded +to a size of KVM_STATS_NAME_LEN; +This ioclt only needs to be called once on running VMs on the same architecture. + +4.133 KVM_STATS_GET_DATA +------------------------- + +:Capability: KVM_CAP_STATS_BINARY_FORM +:Architectures: all +:Type: vm ioctl, vcpu ioctl +:Parameters: struct kvm_stats_data (in/out) +:Returns: 0 on success, < 0 on error + +:: + + struct kvm_stats_data { + __u32 size; + __u64 data[0]; + }; + +This ioctl is used to get the aggregated statistics data for VM or vCPU. +Users must use KVM_STATS_GET_INFO to find the number of statistics. +They must allocate a buffer of the appropriate size num_stats * sizeof(data[0]) +immediately following struct kvm_stats_data. The size field of kvm_stats_data +must contain the buffer size as an input. +The data buffer 1-1 maps to name strings buffer in sequential order. +This ioctl is usually called periodically to pull statistics data. + 5. The kvm_run structure ======================== @@ -6721,3 +6791,12 @@ vcpu_info is set. The KVM_XEN_HVM_CONFIG_RUNSTATE flag indicates that the runstate-related features KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_ADDR/_CURRENT/_DATA/_ADJUST are supported by the KVM_XEN_VCPU_SET_ATTR/KVM_XEN_VCPU_GET_ATTR ioctls. + +8.31 KVM_CAP_STATS_BINARY_FORM +------------------------------ + +:Architectures: all + +This capability indicates that KVM supports retrieving aggregated statistics +data in binary format with corresponding VM/VCPU ioctl KVM_STATS_GET_INFO, +KVM_STATS_GET_NAMES and KVM_STATS_GET_DATA. diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h index 1ea297458306..f2dabf457717 100644 --- a/include/linux/kvm_host.h +++ b/include/linux/kvm_host.h @@ -1164,7 +1164,6 @@ static inline bool kvm_is_error_gpa(struct kvm *kvm, gpa_t gpa) #define VM_STAT_COUNT (sizeof(struct kvm_vm_stat)/sizeof(ulong)) #define VCPU_STAT_COUNT (sizeof(struct kvm_vcpu_stat)/sizeof(u64)) -#define KVM_STATS_NAME_LEN 32 /* Make sure it is synced with fields in struct kvm_vm_stat. */ extern const char kvm_vm_stat_strings[][KVM_STATS_NAME_LEN]; diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h index f6afee209620..ad185d4c5e42 100644 --- a/include/uapi/linux/kvm.h +++ b/include/uapi/linux/kvm.h @@ -1078,6 +1078,7 @@ struct kvm_ppc_resize_hpt { #define KVM_CAP_DIRTY_LOG_RING 192 #define KVM_CAP_X86_BUS_LOCK_EXIT 193 #define KVM_CAP_PPC_DAWR1 194 +#define KVM_CAP_STATS_BINARY_FORM 195 #ifdef KVM_CAP_IRQ_ROUTING @@ -1853,4 +1854,63 @@ struct kvm_dirty_gfn { #define KVM_BUS_LOCK_DETECTION_OFF (1 << 0) #define KVM_BUS_LOCK_DETECTION_EXIT (1 << 1) +/* Available with KVM_CAP_STATS_BINARY_FORM */ + +#define KVM_STATS_NAME_LEN 32 + +/** + * struct kvm_stats_info - statistics information + * + * Used as parameter for ioctl %KVM_STATS_GET_INFO. + * + * @num_stats: On return, the number of statistics data of vm or vcpu. + * + */ +struct kvm_stats_info { + __u32 num_stats; +}; + +/** + * struct kvm_stats_names - string list of statistics names + * + * Used as parameter for ioctl %KVM_STATS_GET_NAMES. + * + * @size: Input from user, indicating the size of buffer after the struture. + * @names: Buffer of name string list for vm or vcpu. Each string is + * null-padded to a size of %KVM_STATS_NAME_LEN. + * + * Users must use %KVM_STATS_GET_INFO to find the number of + * statistics. They must allocate a buffer of the appropriate + * size (>= &struct kvm_stats_info @num_stats * %KVM_STATS_NAME_LEN) + * immediately following this struture. + */ +struct kvm_stats_names { + __u32 size; + __u8 names[0]; +}; + +/** + * struct kvm_stats_data - statistics data array + * + * Used as parameter for ioctl %KVM_STATS_GET_DATA. + * + * @size: Input from user, indicating the size of buffer after the struture. + * @data: Buffer of statistics data for vm or vcpu. + * + * Users must use %KVM_STATS_GET_INFO to find the number of + * statistics. They must allocate a buffer of the appropriate + * size (>= &struct kvm_stats_info @num_stats * sizeof(@data[0]) + * immediately following this structure. + * &struct kvm_stats_names @names 1-1 maps to &structkvm_stats_data + * @data in sequential order. + */ +struct kvm_stats_data { + __u32 size; + __u64 data[0]; +}; + +#define KVM_STATS_GET_INFO _IOR(KVMIO, 0xcc, struct kvm_stats_info) +#define KVM_STATS_GET_NAMES _IOR(KVMIO, 0xcd, struct kvm_stats_names) +#define KVM_STATS_GET_DATA _IOR(KVMIO, 0xce, struct kvm_stats_data) + #endif /* __LINUX_KVM_H */ From patchwork Wed Mar 10 00:30:23 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jing Zhang X-Patchwork-Id: 12126777 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-26.3 required=3.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT,USER_IN_DEF_DKIM_WL autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7FEB2C4361B for ; Wed, 10 Mar 2021 00:31:47 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 6DF8C650F3 for ; Wed, 10 Mar 2021 00:31:47 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231590AbhCJAbS (ORCPT ); Tue, 9 Mar 2021 19:31:18 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48026 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231430AbhCJAap (ORCPT ); Tue, 9 Mar 2021 19:30:45 -0500 Received: from mail-il1-x149.google.com (mail-il1-x149.google.com [IPv6:2607:f8b0:4864:20::149]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C809BC061762 for ; Tue, 9 Mar 2021 16:30:45 -0800 (PST) Received: by mail-il1-x149.google.com with SMTP id g3so11568911ild.4 for ; Tue, 09 Mar 2021 16:30:45 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=HYwIHVMurXa3R6as3OvUxWmJFUBMLjiRzzhIiiKP4ME=; b=KlgzRB+CEZgxcFGOn//lNka3ixGNj1ZMzKq7WAvbwDFq3xRkgAS3kYK/JIV4nIxm/u 1FfbdecWvmBbdiWVheE3wUNE32IOWAGMhu8MeFMpPUxkNG6Ic6IXrOYz15juiE5W+eN/ UwufP8xnomHHhYJZizlFxCzJtMQMPP3AGyXKTMDhs5E9C0vskRVTcj7UvkXA1PH14ykl ft27CoJWrjGy2SvqG2c1AGionh3n73Ki0G54VqY7GeECtpHBPlD1in+kzQ+UDi+3daXg fS/ssqaH/09kuWnDkSliepIZRP1LHJvuV+kQD5aXzLq5vN3FattwTAMNMi+qTW2bJSmf Tddw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=HYwIHVMurXa3R6as3OvUxWmJFUBMLjiRzzhIiiKP4ME=; b=dfU8RFWO8D7W66Q6stwRDvwaR4OU2ZyoTxfufs9IZla2diyY31raoiVXrYnRThj+zm WvrDym6sItV4yrYPQwr1H+PXhRRcNt/ALsd0Si3o47/JOpOG0OVncw12YM7sS0B8Gqa7 cm4b5lujJiUNQwXIPmYoy7L1PF+OQRvybaHpJgQ0XOGh4oSmyaJVeSvmaqauz4jDUNvO tr4eGOfNEU1tPxQQEgnIQdFGKYDPMXjXW2EkPSzcB0GeLag8lrlGFe9FB+wHHLS4mMFL N0nx3EX2wEAgsYsGrRedq1DI2KY5bCOnVbJliE+14oraqfmC+fnttWJSWxUHDPqgipbO BMeQ== X-Gm-Message-State: AOAM533yi1S1T8fo/3DeTV7qv0C1W40c0J5Y9e/jqKMbtDsuDtgKZRFr NkXP0rp9QUKm4ROCnRuOVlYfkj3Lq5apJjlhhsndT97B36SNKXhZxw/OXjr64EwRhltq/6kc6X1 s3VKH1P72nX9Yfz4mqT9VMj4vaEKqMkUup9ZZjrj0fx7EL4lRsHG7c239d2TPg9+sD8exlmE= X-Google-Smtp-Source: ABdhPJza+jn+PY8flshTTgOAKq9hoAYgUHER9XS+P4s7skBsrShHEuKgzkWZTeYGcckPt9nBzOg82EPVRau5TPgGJA== X-Received: from jingzhangos.c.googlers.com ([fda3:e722:ac3:10:2b:ff92:c0a8:513]) (user=jingzhangos job=sendgmr) by 2002:a6b:6f14:: with SMTP id k20mr642440ioc.52.1615336245163; Tue, 09 Mar 2021 16:30:45 -0800 (PST) Date: Wed, 10 Mar 2021 00:30:23 +0000 In-Reply-To: <20210310003024.2026253-1-jingzhangos@google.com> Message-Id: <20210310003024.2026253-4-jingzhangos@google.com> Mime-Version: 1.0 References: <20210310003024.2026253-1-jingzhangos@google.com> X-Mailer: git-send-email 2.30.1.766.gb4fecdf3b7-goog Subject: [RFC PATCH 3/4] KVM: stats: Add ioctl commands to pull statistics in binary format From: Jing Zhang To: KVM , KVM ARM , Linux MIPS , KVM PPC , Linux S390 , Linux kselftest , Paolo Bonzini , Marc Zyngier , James Morse , Julien Thierry , Suzuki K Poulose , Will Deacon , Huacai Chen , Aleksandar Markovic , Thomas Bogendoerfer , Paul Mackerras , Christian Borntraeger , Janosch Frank , David Hildenbrand , Cornelia Huck , Claudio Imbrenda , Sean Christopherson , Vitaly Kuznetsov , Jim Mattson , Peter Shier , Oliver Upton , David Rientjes , Emanuele Giuseppe Esposito Cc: Jing Zhang Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Three ioctl commands are added to support binary form statistics data retrieval. KVM_STATS_GET_INFO, KVM_STATS_GET_NAMES, KVM_STATS_GET_DATA. KVM_CAP_STATS_BINARY_FORM indicates the capability. Signed-off-by: Jing Zhang --- virt/kvm/kvm_main.c | 115 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 115 insertions(+) diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c index 383df23514b9..87dd62516c8b 100644 --- a/virt/kvm/kvm_main.c +++ b/virt/kvm/kvm_main.c @@ -3464,6 +3464,51 @@ static long kvm_vcpu_ioctl(struct file *filp, r = kvm_arch_vcpu_ioctl_set_fpu(vcpu, fpu); break; } + case KVM_STATS_GET_INFO: { + struct kvm_stats_info stats_info; + + r = -EFAULT; + stats_info.num_stats = VCPU_STAT_COUNT; + if (copy_to_user(argp, &stats_info, sizeof(stats_info))) + goto out; + r = 0; + break; + } + case KVM_STATS_GET_NAMES: { + struct kvm_stats_names stats_names; + + r = -EFAULT; + if (copy_from_user(&stats_names, argp, sizeof(stats_names))) + goto out; + r = -EINVAL; + if (stats_names.size < VCPU_STAT_COUNT * KVM_STATS_NAME_LEN) + goto out; + + r = -EFAULT; + if (copy_to_user(argp + sizeof(stats_names), + kvm_vcpu_stat_strings, + VCPU_STAT_COUNT * KVM_STATS_NAME_LEN)) + goto out; + r = 0; + break; + } + case KVM_STATS_GET_DATA: { + struct kvm_stats_data stats_data; + + r = -EFAULT; + if (copy_from_user(&stats_data, argp, sizeof(stats_data))) + goto out; + r = -EINVAL; + if (stats_data.size < sizeof(vcpu->stat)) + goto out; + + r = -EFAULT; + argp += sizeof(stats_data); + if (copy_to_user(argp, &vcpu->stat, sizeof(vcpu->stat))) + goto out; + r = 0; + break; + } default: r = kvm_arch_vcpu_ioctl(filp, ioctl, arg); } @@ -3695,6 +3740,7 @@ static long kvm_vm_ioctl_check_extension_generic(struct kvm *kvm, long arg) case KVM_CAP_CHECK_EXTENSION_VM: case KVM_CAP_ENABLE_CAP_VM: case KVM_CAP_HALT_POLL: + case KVM_CAP_STATS_BINARY_FORM: return 1; #ifdef CONFIG_KVM_MMIO case KVM_CAP_COALESCED_MMIO: @@ -3825,6 +3871,40 @@ static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm, } } +static long kvm_vm_ioctl_stats_get_data(struct kvm *kvm, unsigned long arg) +{ + void __user *argp = (void __user *)arg; + struct kvm_vcpu *vcpu; + struct kvm_stats_data stats_data; + u64 *data = NULL, *pdata; + int i, j, ret = 0; + size_t dsize = (VM_STAT_COUNT + VCPU_STAT_COUNT) * sizeof(*data); + + + if (copy_from_user(&stats_data, argp, sizeof(stats_data))) + return -EFAULT; + if (stats_data.size < dsize) + return -EINVAL; + data = kzalloc(dsize, GFP_KERNEL_ACCOUNT); + if (!data) + return -ENOMEM; + + for (i = 0; i < VM_STAT_COUNT; i++) + *(data + i) = *((ulong *)&kvm->stat + i); + + kvm_for_each_vcpu(j, vcpu, kvm) { + pdata = data + VM_STAT_COUNT; + for (i = 0; i < VCPU_STAT_COUNT; i++, pdata++) + *pdata += *((u64 *)&vcpu->stat + i); + } + + if (copy_to_user(argp + sizeof(stats_data), data, dsize)) + ret = -EFAULT; + + kfree(data); + return ret; +} + static long kvm_vm_ioctl(struct file *filp, unsigned int ioctl, unsigned long arg) { @@ -4001,6 +4081,41 @@ static long kvm_vm_ioctl(struct file *filp, r = 0; break; } + case KVM_STATS_GET_INFO: { + struct kvm_stats_info stats_info; + + r = -EFAULT; + stats_info.num_stats = VM_STAT_COUNT + VCPU_STAT_COUNT; + if (copy_to_user(argp, &stats_info, sizeof(stats_info))) + goto out; + r = 0; + break; + } + case KVM_STATS_GET_NAMES: { + struct kvm_stats_names stats_names; + + r = -EFAULT; + if (copy_from_user(&stats_names, argp, sizeof(stats_names))) + goto out; + r = -EINVAL; + if (stats_names.size < + (VM_STAT_COUNT + VCPU_STAT_COUNT) * KVM_STATS_NAME_LEN) + goto out; + r = -EFAULT; + argp += sizeof(stats_names); + if (copy_to_user(argp, kvm_vm_stat_strings, + VM_STAT_COUNT * KVM_STATS_NAME_LEN)) + goto out; + argp += VM_STAT_COUNT * KVM_STATS_NAME_LEN; + if (copy_to_user(argp, kvm_vcpu_stat_strings, + VCPU_STAT_COUNT * KVM_STATS_NAME_LEN)) + goto out; + r = 0; + break; + } + case KVM_STATS_GET_DATA: + r = kvm_vm_ioctl_stats_get_data(kvm, arg); + break; case KVM_CHECK_EXTENSION: r = kvm_vm_ioctl_check_extension_generic(kvm, arg); break; From patchwork Wed Mar 10 00:30:24 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jing Zhang X-Patchwork-Id: 12126775 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-26.3 required=3.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT,USER_IN_DEF_DKIM_WL autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id D52FEC15509 for ; Wed, 10 Mar 2021 00:31:47 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id AA139650F3 for ; Wed, 10 Mar 2021 00:31:47 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231607AbhCJAbS (ORCPT ); Tue, 9 Mar 2021 19:31:18 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48042 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231464AbhCJAar (ORCPT ); Tue, 9 Mar 2021 19:30:47 -0500 Received: from mail-qv1-xf49.google.com (mail-qv1-xf49.google.com [IPv6:2607:f8b0:4864:20::f49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4B42AC061762 for ; Tue, 9 Mar 2021 16:30:47 -0800 (PST) Received: by mail-qv1-xf49.google.com with SMTP id bt20so2584347qvb.0 for ; Tue, 09 Mar 2021 16:30:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=DHxB02lHBuSNm1Tq7ppWLhclQ6LGjD2vwbT8+0hyBYQ=; b=i9nnGI1yJf5zkDtvuzAcFHkNKf3iYy4fMgWPsn0CUr62qyKKEML7n/XqRiL4DuhrVD lOYIjYImLQHRMCLtPvlKUFDxo1P7/lsLESUmJw0tVdAgsA54KJz5QlWXoqESVY0fXkYS KJ+M9fOfot6eeFDCrwoGSqeBqbJGQEoxwG3zMnPXqpV5ZMbroRPNsnIYd1I9SoaLcNfV 2Ehb5DHXA9zswPk9gJK87g+ScrbL46n7nqhZIrrsCH9ySbP5XLo+k2xO9bYMaYPpHUpH b8ohv5kWZiy5uVMb+jik0GkoEQUvObXLnigZ2hmjx/h3f8OYWB2BIEzR/TH2cjB1N4wS TlfA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=DHxB02lHBuSNm1Tq7ppWLhclQ6LGjD2vwbT8+0hyBYQ=; b=AaCcBvTy6b5RMSvzwvnn6K5r9hySjbkjFl8rC1gei+YTN0y5STR8R71Ai7Alt7v/ju Lnj0rXplLXv9gT9xJO/Z/IUO/svF41HK2LUaaE4wyJGlFXD002wQOcKf7zOvorPLeuVw G11Sr/7zrG4WUAbwMfZf515bXeMCahSQqrUjkIztn0u9uBx//ffyBuWu4mCLfPnQuzTV HHh4G3VX58sOkujxGjsGsJaHtn2eExn+wANmr2s9PfkfjM6dDj4TNGNpsiU8+G/e+TgS inz2UbitDpRBCJ7afMD4KUhuObi0gbF3/3GRAv15tS+qe4tf8EDIpgs80WLpjN1LgSNP 7XKg== X-Gm-Message-State: AOAM532BkG4fYrdEQyxtHpp+cFjiaoElXFZCuWl0W4n99tc40cSzlxG3 hlaop/RhP/48GCpJp0rjT5slW6Gdw8S0NoIwZH026RPVBzu8/EV+7AV9DwH+Kej82BQbnxNgkzS GlnLHZuqvSsIxi2zEqC8lsicxN8UHcR/Xnix8cQhH0kJ0AooKsxI/JQuC9WyKQ5tIboMTwjc= X-Google-Smtp-Source: ABdhPJyUNUM/sAdenGIGgvVPCloQCo5gPdn0LHQMLGSw3kNLQg8mscQ8MFWXB1+jfVgEjigVvGqt7memgn4xEsF28w== X-Received: from jingzhangos.c.googlers.com ([fda3:e722:ac3:10:2b:ff92:c0a8:513]) (user=jingzhangos job=sendgmr) by 2002:a0c:9e15:: with SMTP id p21mr678608qve.53.1615336246323; Tue, 09 Mar 2021 16:30:46 -0800 (PST) Date: Wed, 10 Mar 2021 00:30:24 +0000 In-Reply-To: <20210310003024.2026253-1-jingzhangos@google.com> Message-Id: <20210310003024.2026253-5-jingzhangos@google.com> Mime-Version: 1.0 References: <20210310003024.2026253-1-jingzhangos@google.com> X-Mailer: git-send-email 2.30.1.766.gb4fecdf3b7-goog Subject: [RFC PATCH 4/4] KVM: selftests: Add selftest for KVM binary form statistics interface From: Jing Zhang To: KVM , KVM ARM , Linux MIPS , KVM PPC , Linux S390 , Linux kselftest , Paolo Bonzini , Marc Zyngier , James Morse , Julien Thierry , Suzuki K Poulose , Will Deacon , Huacai Chen , Aleksandar Markovic , Thomas Bogendoerfer , Paul Mackerras , Christian Borntraeger , Janosch Frank , David Hildenbrand , Cornelia Huck , Claudio Imbrenda , Sean Christopherson , Vitaly Kuznetsov , Jim Mattson , Peter Shier , Oliver Upton , David Rientjes , Emanuele Giuseppe Esposito Cc: Jing Zhang Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Check if the KVM binary form statistics works correctly and whether the statistics name strings are synced correctly with KVM internal stats data. Signed-off-by: Jing Zhang --- tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 3 + .../selftests/kvm/kvm_bin_form_stats.c | 89 +++++++++++++++++++ 3 files changed, 93 insertions(+) create mode 100644 tools/testing/selftests/kvm/kvm_bin_form_stats.c diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore index 32b87cc77c8e..0c8241bd9a17 100644 --- a/tools/testing/selftests/kvm/.gitignore +++ b/tools/testing/selftests/kvm/.gitignore @@ -38,3 +38,4 @@ /memslot_modification_stress_test /set_memory_region_test /steal_time +/kvm_bin_form_stats diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile index a6d61f451f88..5cdd52ccedf2 100644 --- a/tools/testing/selftests/kvm/Makefile +++ b/tools/testing/selftests/kvm/Makefile @@ -72,6 +72,7 @@ TEST_GEN_PROGS_x86_64 += kvm_create_max_vcpus TEST_GEN_PROGS_x86_64 += memslot_modification_stress_test TEST_GEN_PROGS_x86_64 += set_memory_region_test TEST_GEN_PROGS_x86_64 += steal_time +TEST_GEN_PROGS_x86_64 += kvm_bin_form_stats TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list-sve @@ -81,6 +82,7 @@ TEST_GEN_PROGS_aarch64 += dirty_log_perf_test TEST_GEN_PROGS_aarch64 += kvm_create_max_vcpus TEST_GEN_PROGS_aarch64 += set_memory_region_test TEST_GEN_PROGS_aarch64 += steal_time +TEST_GEN_PROGS_aarch64 += kvm_bin_form_stats TEST_GEN_PROGS_s390x = s390x/memop TEST_GEN_PROGS_s390x += s390x/resets @@ -89,6 +91,7 @@ TEST_GEN_PROGS_s390x += demand_paging_test TEST_GEN_PROGS_s390x += dirty_log_test TEST_GEN_PROGS_s390x += kvm_create_max_vcpus TEST_GEN_PROGS_s390x += set_memory_region_test +TEST_GEN_PROGS_s390x += kvm_bin_form_stats TEST_GEN_PROGS += $(TEST_GEN_PROGS_$(UNAME_M)) LIBKVM += $(LIBKVM_$(UNAME_M)) diff --git a/tools/testing/selftests/kvm/kvm_bin_form_stats.c b/tools/testing/selftests/kvm/kvm_bin_form_stats.c new file mode 100644 index 000000000000..36cf206470b1 --- /dev/null +++ b/tools/testing/selftests/kvm/kvm_bin_form_stats.c @@ -0,0 +1,89 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * kvm_bin_form_stats + * + * Copyright (C) 2021, Google LLC. + * + * Test for fd-based IOCTL commands for retrieving KVM statistics data in + * binary form. KVM_CAP_STATS_BINARY_FORM, KVM_STATS_GET_INFO, + * KVM_STATS_GET_NAMES and KVM_STATS_GET_DATA are checked. + */ + +#define _GNU_SOURCE /* for program_invocation_short_name */ +#include +#include +#include +#include + +#include "test_util.h" + +#include "kvm_util.h" +#include "asm/kvm.h" +#include "linux/kvm.h" + +int main(int argc, char *argv[]) +{ + struct kvm_stats_info stats_info = {0}; + struct kvm_stats_names *stats_names; + struct kvm_stats_data *stats_data; + struct kvm_vm *kvm; + int i, ret; + + kvm = vm_create(VM_MODE_DEFAULT, DEFAULT_GUEST_PHY_PAGES, O_RDWR); + + ret = kvm_check_cap(KVM_CAP_STATS_BINARY_FORM); + if (ret < 0) { + pr_info("Binary form statistics interface is not supported!\n"); + goto out_free_kvm; + } + + ret = -1; + vm_ioctl(kvm, KVM_STATS_GET_INFO, &stats_info); + if (stats_info.num_stats == 0) { + pr_info("KVM_STATS_GET_INFO failed!\n"); + pr_info("Or the number of stistics data is zero.\n"); + goto out_free_kvm; + } + + /* Allocate memory for stats name strings and value */ + stats_names = malloc(sizeof(*stats_names) + + stats_info.num_stats * KVM_STATS_NAME_LEN); + if (!stats_names) { + pr_info("Memory allocation failed!\n"); + goto out_free_kvm; + } + + stats_data = malloc(sizeof(*stats_data) + + stats_info.num_stats * sizeof(__u64)); + if (!stats_data) { + pr_info("Memory allocation failed!\n"); + goto out_free_names; + } + + /* Retrieve the name strings and data */ + stats_names->size = stats_info.num_stats * KVM_STATS_NAME_LEN; + vm_ioctl(kvm, KVM_STATS_GET_NAMES, stats_names); + + stats_data->size = stats_info.num_stats * sizeof(__u64); + vm_ioctl(kvm, KVM_STATS_GET_DATA, stats_data); + + /* Display supported statistics names */ + for (i = 0; i < (int)stats_info.num_stats; i++) { + char *name = (char *)stats_names->names + i * KVM_STATS_NAME_LEN; + + if (strnlen(name, KVM_STATS_NAME_LEN) == 0) { + pr_info("Empty stats name at offset %d!\n", i); + goto out_free_data; + } + pr_info("%s\n", name); + } + + ret = 0; +out_free_data: + free(stats_data); +out_free_names: + free(stats_names); +out_free_kvm: + kvm_vm_free(kvm); + return ret; +}