From nobody Mon Feb 9 19:55:42 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1650982720756502.0281328182481; Tue, 26 Apr 2022 07:18:40 -0700 (PDT) Received: from localhost ([::1]:42304 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1njM1X-0008GA-45 for importer@patchew.org; Tue, 26 Apr 2022 10:18:39 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:38124) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1njLzO-0005RD-LC for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:26 -0400 Received: from mail-wm1-x332.google.com ([2a00:1450:4864:20::332]:38426) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1njLzM-0005W3-9N for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:26 -0400 Received: by mail-wm1-x332.google.com with SMTP id 1-20020a05600c248100b00393fbf11a05so580240wms.3 for ; Tue, 26 Apr 2022 07:16:23 -0700 (PDT) Received: from avogadro.lan ([2001:b07:6468:f312:e3ec:5559:7c5c:1928]) by smtp.gmail.com with ESMTPSA id o6-20020a05600c378600b0038eca3cdbb3sm11206464wmr.13.2022.04.26.07.16.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 26 Apr 2022 07:16:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=CCO3cumqklouz/cXZlyJMH925uFvy/ejsoSwQmeA6f0=; b=Sn7kYMV6y1VsV4TV9HXiamz9doZCOUwBnPb5RCG+g6iAUkRnpkgVn0xYlgezMZ7XuM Vq69vzahhnl+APD58oqw2hFQU5jyCgMEynqj8BygqyQPXf5/1S0xqXRD7R+bY0PiWrTK bjWRYNgu6cwyNZDurE79c0GQyrpBzyX0mAwhZc2i4d5cQ/F+d/drIybu8S1eFpcY/83M ytTyBuDaqKTIdaLk8mgVVju5g6UfH9hlrqI9es2BsaJh81eX6ntimtJtd5/d1ybQ4Xh6 T0t+aU1D0b6f3A/+t8jnLspFiAZGiU56vF2TbbkgpXj0BWNidJguq9qTAZsnxPcWtb5H oxxw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-transfer-encoding; bh=CCO3cumqklouz/cXZlyJMH925uFvy/ejsoSwQmeA6f0=; b=HCWHU1p2j7uT6cAPZ9SnrhJUZiaJiN+9xwkzYpJxKMR934C9rJqzfiq6ieoWiTYCOo xDvgjXpW3FIdmDB0RJbaIDldmWcrGBiLTjLgiyQSsYEx2xiUIymhWbJmOPkWDlwBQ1Jw tarsXH26eCh9rWQKYZXR1SyfNS9KvHoVoxDUDFDYo/12kR1wa8oY8Vvk/oLuzmB7sO0A 1ZQ4GNNjPyRpOju9UtWW/K6u/zVc6n7lvW2J8APq3rmkjB6Noj27Wz4MeBUlfwFqNtPH mlS2pKCrpl9bjN2RLcti0XIrAqlKiB5vT2cgunWjR3PW2Ph+gImDhP/ZxUQWsp4vLlJt MDvg== X-Gm-Message-State: AOAM533eWCKhxWk0EFMfZegBeAkQPGNHra8/GwaLaJe6T48AuhIzsnZd M0w2Pi663lvgIIQcEf+/nMxkcUuq2SIC7g== X-Google-Smtp-Source: ABdhPJzWirqLIpkcjF3Ez7HLQva57A1i2n3sp0LuBhqVPy4m34lSmMWj7D7AD27py4qrXyAjoIBRTA== X-Received: by 2002:a7b:c20c:0:b0:38f:fac1:fe05 with SMTP id x12-20020a7bc20c000000b0038ffac1fe05mr31261011wmi.144.1650982582433; Tue, 26 Apr 2022 07:16:22 -0700 (PDT) From: Paolo Bonzini To: qemu-devel@nongnu.org Subject: [PATCH 1/8] qmp: Support for querying stats Date: Tue, 26 Apr 2022 16:16:12 +0200 Message-Id: <20220426141619.304611-2-pbonzini@redhat.com> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220426141619.304611-1-pbonzini@redhat.com> References: <20220426141619.304611-1-pbonzini@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::332; envelope-from=paolo.bonzini@gmail.com; helo=mail-wm1-x332.google.com X-Spam_score_int: -14 X-Spam_score: -1.5 X-Spam_bar: - X-Spam_report: (-1.5 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FORGED_FROMDOMAIN=0.249, FREEMAIL_FROM=0.001, HEADER_FROM_DIFFERENT_DOMAINS=0.249, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: berrange@redhat.com, armbru@redhat.com, dgilbert@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZM-MESSAGEID: 1650983625190100001 Content-Type: text/plain; charset="utf-8" From: Mark Kanda Introduce QMP support for querying stats. Provide a framework for adding new stats and support for the following commands: - query-stats Returns a list of all stats per target type (only VM and vCPU to start), wi= th additional options for specifying stat names, vCPU qom paths, and providers. - query-stats-schemas Returns a list of stats included in each target type, with an option for specifying the provider. The concepts in the schema are based on the KVM binary stats' own introspection data, just translated to QAPI. The framework provides a method to register callbacks for these QMP command= s. Most of the work in fact is done by the callbacks, and a large majority of this patch is new QAPI structs and commands. The first use-case will be for fd-based KVM stats (in an upcoming patch). Examples (with fd-based KVM stats): - Query all VM stats: { "execute": "query-stats", "arguments" : { "target": "vm" } } { "return": [ { "provider": "kvm", "stats": [ { "name": "max_mmu_page_hash_collisions", "value": 0 }, { "name": "max_mmu_rmap_size", "value": 0 }, { "name": "nx_lpage_splits", "value": 148 }, ... ] }, { "provider": "xyz", "stats": [ ... ] } ] } - Query all vCPU stats: { "execute": "query-stats", "arguments" : { "target": "vcpu" } } { "return": [ { "provider": "kvm", "qom_path": "/machine/unattached/device[0]" "stats": [ { "name": "guest_mode", "value": 0 }, { "name": "directed_yield_successful", "value": 0 }, { "name": "directed_yield_attempted", "value": 106 }, ... ] }, { "provider": "kvm", "qom_path": "/machine/unattached/device[1]" "stats": [ { "name": "guest_mode", "value": 0 }, { "name": "directed_yield_successful", "value": 0 }, { "name": "directed_yield_attempted", "value": 106 }, ... ] }, ] } - Retrieve the schemas: { "execute": "query-stats-schemas" } { "return": [ { "provider": "kvm", "target": "vcpu", "stats": [ { "name": "guest_mode", "unit": "none", "base": 10, "exponent": 0, "type": "instant" }, { "name": "directed_yield_successful", "unit": "none", "base": 10, "exponent": 0, "type": "cumulative" }, ... ] }, { "provider": "kvm", "target": "vm", "stats": [ { "name": "max_mmu_page_hash_collisions", "unit": "none", "base": 10, "exponent": 0, "type": "peak" }, ... ] }, { "provider": "xyz", "target": "vm", "stats": [ ... ] } ] } Signed-off-by: Mark Kanda Signed-off-by: Paolo Bonzini --- include/monitor/stats.h | 33 +++++++ monitor/qmp-cmds.c | 71 +++++++++++++++ qapi/meson.build | 1 + qapi/qapi-schema.json | 1 + qapi/stats.json | 192 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 298 insertions(+) create mode 100644 include/monitor/stats.h create mode 100644 qapi/stats.json diff --git a/include/monitor/stats.h b/include/monitor/stats.h new file mode 100644 index 0000000000..89552ab06f --- /dev/null +++ b/include/monitor/stats.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2022 Oracle and/or its affiliates. + * + * This work is licensed under the terms of the GNU GPL, version 2. + * See the COPYING file in the top-level directory. + */ + +#ifndef STATS_H +#define STATS_H + +#include "qapi/qapi-types-stats.h" + +typedef void StatRetrieveFunc(StatsResultList **result, StatsTarget target= , Error **errp); +typedef void SchemaRetrieveFunc(StatsSchemaList **result, Error **errp); + +/* + * Register callbacks for the QMP query-stats command. + * + * @stats_fn: routine to query stats: + * @schema_fn: routine to query stat schemas: + */ +void add_stats_callbacks(StatRetrieveFunc *stats_fn, + SchemaRetrieveFunc *schemas_fn); + +/* + * Helper routines for adding stats entries to the results lists. + */ +void add_stats_entry(StatsResultList **, StatsProvider, const char *id, + StatsList *stats_list); +void add_stats_schema(StatsSchemaList **, StatsProvider, StatsTarget, + StatsSchemaValueList *); + +#endif /* STATS_H */ diff --git a/monitor/qmp-cmds.c b/monitor/qmp-cmds.c index 5e7302cbb9..97825b25fa 100644 --- a/monitor/qmp-cmds.c +++ b/monitor/qmp-cmds.c @@ -35,6 +35,7 @@ #include "qapi/qapi-commands-control.h" #include "qapi/qapi-commands-machine.h" #include "qapi/qapi-commands-misc.h" +#include "qapi/qapi-commands-stats.h" #include "qapi/qapi-commands-ui.h" #include "qapi/type-helpers.h" #include "qapi/qmp/qerror.h" @@ -43,6 +44,7 @@ #include "hw/acpi/acpi_dev_interface.h" #include "hw/intc/intc.h" #include "hw/rdma/rdma.h" +#include "monitor/stats.h" =20 NameInfo *qmp_query_name(Error **errp) { @@ -426,3 +428,72 @@ HumanReadableText *qmp_x_query_irq(Error **errp) =20 return human_readable_text_from_str(buf); } + +typedef struct StatsCallbacks { + StatRetrieveFunc *stats_cb; + SchemaRetrieveFunc *schemas_cb; + QTAILQ_ENTRY(StatsCallbacks) next; +} StatsCallbacks; + +static QTAILQ_HEAD(, StatsCallbacks) stats_callbacks =3D + QTAILQ_HEAD_INITIALIZER(stats_callbacks); + +void add_stats_callbacks(StatRetrieveFunc *stats_fn, + SchemaRetrieveFunc *schemas_fn) +{ + StatsCallbacks *entry =3D g_new(StatsCallbacks, 1); + entry->stats_cb =3D stats_fn; + entry->schemas_cb =3D schemas_fn; + + QTAILQ_INSERT_TAIL(&stats_callbacks, entry, next); +} + +StatsResultList *qmp_query_stats(StatsFilter *filter, Error **errp) +{ + StatsResultList *stats_results =3D NULL; + StatsCallbacks *entry; + + QTAILQ_FOREACH(entry, &stats_callbacks, next) { + entry->stats_cb(&stats_results, filter->target, errp); + } + + return stats_results; +} + +StatsSchemaList *qmp_query_stats_schemas(Error **errp) +{ + StatsSchemaList *stats_results =3D NULL; + StatsCallbacks *entry; + + QTAILQ_FOREACH(entry, &stats_callbacks, next) { + entry->schemas_cb(&stats_results, errp); + } + + return stats_results; +} + +void add_stats_entry(StatsResultList **stats_results, StatsProvider provid= er, + const char *qom_path, StatsList *stats_list) +{ + StatsResult *entry =3D g_new0(StatsResult, 1); + entry->provider =3D provider; + if (qom_path) { + entry->has_qom_path =3D true; + entry->qom_path =3D g_strdup(qom_path); + } + entry->stats =3D stats_list; + + QAPI_LIST_PREPEND(*stats_results, entry); +} + +void add_stats_schema(StatsSchemaList **schema_results, + StatsProvider provider, StatsTarget target, + StatsSchemaValueList *stats_list) +{ + StatsSchema *entry =3D g_new0(StatsSchema, 1); + + entry->provider =3D provider; + entry->target =3D target; + entry->stats =3D stats_list; + QAPI_LIST_PREPEND(*schema_results, entry); +} diff --git a/qapi/meson.build b/qapi/meson.build index 656ef0e039..fd5c93d643 100644 --- a/qapi/meson.build +++ b/qapi/meson.build @@ -46,6 +46,7 @@ qapi_all_modules =3D [ 'replay', 'run-state', 'sockets', + 'stats', 'trace', 'transaction', 'yank', diff --git a/qapi/qapi-schema.json b/qapi/qapi-schema.json index 4912b9744e..92d7ecc52c 100644 --- a/qapi/qapi-schema.json +++ b/qapi/qapi-schema.json @@ -93,3 +93,4 @@ { 'include': 'audio.json' } { 'include': 'acpi.json' } { 'include': 'pci.json' } +{ 'include': 'stats.json' } diff --git a/qapi/stats.json b/qapi/stats.json new file mode 100644 index 0000000000..7454dd7daa --- /dev/null +++ b/qapi/stats.json @@ -0,0 +1,192 @@ +# -*- Mode: Python -*- +# vim: filetype=3Dpython +# +# Copyright (c) 2022 Oracle and/or its affiliates. +# +# This work is licensed under the terms of the GNU GPL, version 2 or later. +# See the COPYING file in the top-level directory. +# +# SPDX-License-Identifier: GPL-2.0-or-later + +## +# =3D Statistics +## + +## +# @StatsType: +# +# Enumeration of statistics types +# +# @cumulative: stat is cumulative; value can only increase. +# @instant: stat is instantaneous; value can increase or decrease. +# @peak: stat is the peak value; value can only increase. +# @linear-hist: stat is a linear histogram. +# @log-hist: stat is a logarithmic histogram. +# +# Since: 7.1 +## +{ 'enum' : 'StatsType', + 'data' : [ 'cumulative', 'instant', 'peak', 'linear-hist', 'log-hist' ] } + +## +# @StatsUnit: +# +# Enumeration of unit of measurement for statistics +# +# @bytes: stat reported in bytes. +# @seconds: stat reported in seconds. +# @cycles: stat reported in clock cycles. +# +# Since: 7.1 +## +{ 'enum' : 'StatsUnit', + 'data' : [ 'bytes', 'seconds', 'cycles' ] } + +## +# @StatsProvider: +# +# Enumeration of statistics providers. +# +# Since: 7.1 +## +{ 'enum': 'StatsProvider', + 'data': [ ] } + +## +# @StatsTarget: +# +# The kinds of objects on which one can request statistics. +# +# @vm: the entire virtual machine. +# @vcpu: a virtual CPU. +# +# Since: 7.1 +## +{ 'enum': 'StatsTarget', + 'data': [ 'vm', 'vcpu' ] } + +## +# @StatsFilter: +# +# The arguments to the query-stats command; specifies a target for which to +# request statistics, and which statistics are requested from each provide= r. +# +# Since: 7.1 +## +{ 'struct': 'StatsFilter', + 'data': { 'target': 'StatsTarget' } } + +## +# @StatsValue: +# +# @scalar: single uint64. +# @list: list of uint64. +# +# Since: 7.1 +## +{ 'alternate': 'StatsValue', + 'data': { 'scalar': 'uint64', + 'list': [ 'uint64' ] } } + +## +# @Stats: +# +# @name: name of stat. +# @value: stat value. +# +# Since: 7.1 +## +{ 'struct': 'Stats', + 'data': { 'name': 'str', + 'value' : 'StatsValue' } } + +## +# @StatsResult: +# +# @provider: provider for this set of statistics. +# @qom-path: QOM path of the object for which the statistics are returned +# @stats: list of statistics. +# +# Since: 7.1 +## +{ 'struct': 'StatsResult', + 'data': { 'provider': 'StatsProvider', + '*qom-path': 'str', + 'stats': [ 'Stats' ] } } + +## +# @query-stats: +# +# Return runtime-collected statistics for objects such as the +# VM or its vCPUs. +# +# The arguments are a StatsFilter and specify the provider and objects +# to return statistics about. +# +# Returns: a list of StatsResult, one for each provider and object +# (e.g., for each vCPU). +# +# Since: 7.1 +## +{ 'command': 'query-stats', + 'data': 'StatsFilter', + 'boxed': true, + 'returns': [ 'StatsResult' ] } + +## +# @StatsSchemaValue: +# +# Schema for a single statistic. +# +# @name: stat name. +# +# @type: kind of statistic, a @StatType. +# +# @unit: base unit of measurement for the statistics @StatUnit. +# +# @base: base for the multiple of @unit that the statistic uses, either 2 = or 10. +# Only present if @exponent is non-zero. +# +# @exponent: exponent for the multiple of @unit that the statistic uses +# +# @bucket-size: Used with linear-hist to report the width of each bucket +# of the histogram. +# +# Since: 7.1 +## +{ 'struct': 'StatsSchemaValue', + 'data': { 'name': 'str', + 'type': 'StatsType', + '*unit': 'StatsUnit', + '*base': 'int8', + 'exponent': 'int16', + '*bucket-size': 'uint32' } } + +## +# @StatsSchema: +# +# Schema for all available statistics for a provider and target. +# +# @provider: provider for this set of statistics. +# +# @target: kind of object that can be queried through this provider. +# +# @stats: list of statistics. +# +# Since: 7.1 +## +{ 'struct': 'StatsSchema', + 'data': { 'provider': 'StatsProvider', + 'target': 'StatsTarget', + 'stats': [ 'StatsSchemaValue' ] } } + +## +# @query-stats-schemas: +# +# Return the schema for all available runtime-collected statistics. +# +# Since: 7.1 +## +{ 'command': 'query-stats-schemas', + 'data': { }, + 'returns': [ 'StatsSchema' ] } --=20 2.35.1 From nobody Mon Feb 9 19:55:42 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1650982835608841.0148394188604; Tue, 26 Apr 2022 07:20:35 -0700 (PDT) Received: from localhost ([::1]:49940 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1njM3N-0004t1-30 for importer@patchew.org; Tue, 26 Apr 2022 10:20:33 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:38176) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1njLzP-0005Rj-WF for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:28 -0400 Received: from mail-wm1-x335.google.com ([2a00:1450:4864:20::335]:39862) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1njLzM-0005WC-Ng for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:27 -0400 Received: by mail-wm1-x335.google.com with SMTP id ay11-20020a05600c1e0b00b0038eb92fa965so1599094wmb.4 for ; Tue, 26 Apr 2022 07:16:24 -0700 (PDT) Received: from avogadro.lan ([2001:b07:6468:f312:e3ec:5559:7c5c:1928]) by smtp.gmail.com with ESMTPSA id o6-20020a05600c378600b0038eca3cdbb3sm11206464wmr.13.2022.04.26.07.16.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 26 Apr 2022 07:16:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=UrgpwViBB1MFa3pBwnxNwPfyeMj8oxu0NkxVYcn1+4I=; b=FmtheW/OWMu3wBgqSnCtbdgVo+puKpXXucR4xYMXTLue9YP+scaXYiqhZg5oAryAez emoyRJYeR63lifYDd1f9QKgCWeQ6RwYzj2Yd1FF3AYmYZffYQVqMKRRLPYsYYa4LiHBP WWvXoF/QNBOyFqF1TcuDtJWfaZxyqBH15lUCxIdRP2VyS15rQxBUJyA1frjeMlE0Fvnx Go1mSWA0FxVt3ESV4/KoHyHDJ2zFVFumBP871dW0qlNLFiyLrcIR7xZRMiZYOnQ8FMCZ qcogT18KfJpvLcFB1vK5ZnrZKL33aEHhjOZr+CrrrntgGlzogyHwl7odnWHwVpWGfHac OM7g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-transfer-encoding; bh=UrgpwViBB1MFa3pBwnxNwPfyeMj8oxu0NkxVYcn1+4I=; b=X2p8I3TdqjlZ8auAzNx+K+Nq/5UJpM4CAOek045wl+3MgfXUPKzI0k0/iAJJ5Lu26J haCZw4Jd+pJ99xBlmAVMoiNj+FGe4rTZSJBzDCGlcNQYZouOw3+T0vpYMtzlM26GAiG1 LVU0tQV07VLPa6a02XpseuTRo2gOVoyQWppJR6Mb8Zl24fcLRhvTz14A44oZ1gqGqQgE zEqPvhGW7Vo1pbXqtSishwEMgvLGLLZZ/94An8aDspuuVDZ9UWzuGZW0AUKqx4d/KIux dlgBGmbGIolZJ7V+KNL915B20yKvXGvKVHh8DoN/BL5oz4G5s56Mo1wbmKC1RlZiecsC 9Emg== X-Gm-Message-State: AOAM5313wtYe2XM6LHTc9sZ4xwlx6kHa0EkiiDud3LYuDnQTO+7uZ+Tq qlzsMsV7HomokeF+k9+E0u/xvdtZiM5Mqg== X-Google-Smtp-Source: ABdhPJw2gdaX9cezQmzCF30tfj3iSoSKDLFzfk5L5gRIx9w6JsMRtciV8xRh1WZVDsVDNiPX0pNgRw== X-Received: by 2002:a05:600c:4982:b0:393:db93:7542 with SMTP id h2-20020a05600c498200b00393db937542mr19482313wmp.88.1650982583275; Tue, 26 Apr 2022 07:16:23 -0700 (PDT) From: Paolo Bonzini To: qemu-devel@nongnu.org Subject: [PATCH 2/8] kvm: Support for querying fd-based stats Date: Tue, 26 Apr 2022 16:16:13 +0200 Message-Id: <20220426141619.304611-3-pbonzini@redhat.com> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220426141619.304611-1-pbonzini@redhat.com> References: <20220426141619.304611-1-pbonzini@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::335; envelope-from=paolo.bonzini@gmail.com; helo=mail-wm1-x335.google.com X-Spam_score_int: -14 X-Spam_score: -1.5 X-Spam_bar: - X-Spam_report: (-1.5 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FORGED_FROMDOMAIN=0.249, FREEMAIL_FROM=0.001, HEADER_FROM_DIFFERENT_DOMAINS=0.249, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: berrange@redhat.com, armbru@redhat.com, dgilbert@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZM-MESSAGEID: 1650982837435100001 Content-Type: text/plain; charset="utf-8" From: Mark Kanda Add support for querying fd-based KVM stats - as introduced by Linux kernel commit: cb082bfab59a ("KVM: stats: Add fd-based API to read binary stats data") This allows the user to analyze the behavior of the VM without access to debugfs. Signed-off-by: Mark Kanda Signed-off-by: Paolo Bonzini --- accel/kvm/kvm-all.c | 403 ++++++++++++++++++++++++++++++++++++++++++++ qapi/stats.json | 2 +- 2 files changed, 404 insertions(+), 1 deletion(-) diff --git a/accel/kvm/kvm-all.c b/accel/kvm/kvm-all.c index 32e177bd26..4a753d4445 100644 --- a/accel/kvm/kvm-all.c +++ b/accel/kvm/kvm-all.c @@ -47,6 +47,7 @@ #include "kvm-cpus.h" =20 #include "hw/boards.h" +#include "monitor/stats.h" =20 /* This check must be after config-host.h is included */ #ifdef CONFIG_EVENTFD @@ -2310,6 +2311,9 @@ bool kvm_dirty_ring_enabled(void) return kvm_state->kvm_dirty_ring_size ? true : false; } =20 +static void query_stats_cb(StatsResultList **result, StatsTarget target, E= rror **errp); +static void query_stats_schemas_cb(StatsSchemaList **result, Error **errp); + static int kvm_init(MachineState *ms) { MachineClass *mc =3D MACHINE_GET_CLASS(ms); @@ -2638,6 +2642,10 @@ static int kvm_init(MachineState *ms) } } =20 + if (kvm_check_extension(kvm_state, KVM_CAP_BINARY_STATS_FD)) { + add_stats_callbacks(query_stats_cb, query_stats_schemas_cb); + } + return 0; =20 err: @@ -3697,3 +3705,398 @@ static void kvm_type_init(void) } =20 type_init(kvm_type_init); + +typedef struct StatsArgs { + union StatsResultsType { + StatsResultList **stats; + StatsSchemaList **schema; + } result; + Error **errp; +} StatsArgs; + +static StatsList *add_kvmstat_entry(struct kvm_stats_desc *pdesc, + uint64_t *stats_data, + StatsList *stats_list, + Error **errp) +{ + + StatsList *stats_entry; + Stats *stats; + uint64List *val_list =3D NULL; + + switch (pdesc->flags & KVM_STATS_TYPE_MASK) { + case KVM_STATS_TYPE_CUMULATIVE: + case KVM_STATS_TYPE_INSTANT: + case KVM_STATS_TYPE_PEAK: + case KVM_STATS_TYPE_LINEAR_HIST: + case KVM_STATS_TYPE_LOG_HIST: + break; + default: + return stats_list; + } + + switch (pdesc->flags & KVM_STATS_UNIT_MASK) { + case KVM_STATS_UNIT_NONE: + case KVM_STATS_UNIT_BYTES: + case KVM_STATS_UNIT_CYCLES: + case KVM_STATS_UNIT_SECONDS: + break; + default: + return stats_list; + } + + switch (pdesc->flags & KVM_STATS_BASE_MASK) { + case KVM_STATS_BASE_POW10: + case KVM_STATS_BASE_POW2: + break; + default: + return stats_list; + } + + /* Alloc and populate data list */ + stats_entry =3D g_new0(StatsList, 1); + stats =3D g_new0(Stats, 1); + stats->name =3D g_strdup(pdesc->name); + stats->value =3D g_new0(StatsValue, 1);; + + if (pdesc->size =3D=3D 1) { + stats->value->u.scalar =3D *stats_data; + stats->value->type =3D QTYPE_QNUM; + } else { + int i; + for (i =3D 0; i < pdesc->size; i++) { + uint64List *val_entry =3D g_new0(uint64List, 1); + val_entry->value =3D stats_data[i]; + val_entry->next =3D val_list; + val_list =3D val_entry; + } + stats->value->u.list =3D val_list; + stats->value->type =3D QTYPE_QLIST; + } + + stats_entry->value =3D stats; + stats_entry->next =3D stats_list; + + return stats_entry; +} + +static StatsSchemaValueList *add_kvmschema_entry(struct kvm_stats_desc *pd= esc, + StatsSchemaValueList *lis= t, + Error **errp) +{ + StatsSchemaValueList *schema_entry =3D g_new0(StatsSchemaValueList, 1); + schema_entry->value =3D g_new0(StatsSchemaValue, 1); + + switch (pdesc->flags & KVM_STATS_TYPE_MASK) { + case KVM_STATS_TYPE_CUMULATIVE: + schema_entry->value->type =3D STATS_TYPE_CUMULATIVE; + break; + case KVM_STATS_TYPE_INSTANT: + schema_entry->value->type =3D STATS_TYPE_INSTANT; + break; + case KVM_STATS_TYPE_PEAK: + schema_entry->value->type =3D STATS_TYPE_PEAK; + break; + case KVM_STATS_TYPE_LINEAR_HIST: + schema_entry->value->type =3D STATS_TYPE_LINEAR_HIST; + schema_entry->value->bucket_size =3D pdesc->bucket_size; + schema_entry->value->has_bucket_size =3D true; + break; + case KVM_STATS_TYPE_LOG_HIST: + schema_entry->value->type =3D STATS_TYPE_LOG_HIST; + break; + default: + goto exit; + } + + switch (pdesc->flags & KVM_STATS_UNIT_MASK) { + case KVM_STATS_UNIT_NONE: + break; + case KVM_STATS_UNIT_BYTES: + schema_entry->value->has_unit =3D true; + schema_entry->value->unit =3D STATS_UNIT_BYTES; + break; + case KVM_STATS_UNIT_CYCLES: + schema_entry->value->has_unit =3D true; + schema_entry->value->unit =3D STATS_UNIT_CYCLES; + break; + case KVM_STATS_UNIT_SECONDS: + schema_entry->value->has_unit =3D true; + schema_entry->value->unit =3D STATS_UNIT_SECONDS; + break; + default: + goto exit; + } + + schema_entry->value->exponent =3D pdesc->exponent; + if (pdesc->exponent) { + switch (pdesc->flags & KVM_STATS_BASE_MASK) { + case KVM_STATS_BASE_POW10: + schema_entry->value->has_base =3D true; + schema_entry->value->base =3D 10; + break; + case KVM_STATS_BASE_POW2: + schema_entry->value->has_base =3D true; + schema_entry->value->base =3D 2; + break; + default: + goto exit; + } + } + + schema_entry->value->name =3D g_strdup(pdesc->name); + schema_entry->next =3D list; + return schema_entry; +exit: + g_free(schema_entry->value); + g_free(schema_entry); + return list; +} + +/* Cached stats descriptors */ +typedef struct StatsDescriptors { + char *ident; /* 'vm' or vCPU qom path */ + struct kvm_stats_desc *kvm_stats_desc; + struct kvm_stats_header *kvm_stats_header; + QTAILQ_ENTRY(StatsDescriptors) next; +} StatsDescriptors; + +static QTAILQ_HEAD(, StatsDescriptors) stats_descriptors =3D + QTAILQ_HEAD_INITIALIZER(stats_descriptors); + +static StatsDescriptors *find_stats_descriptors(StatsTarget target, int st= ats_fd, + Error **errp) +{ + StatsDescriptors *descriptors; + const char *ident; + struct kvm_stats_desc *kvm_stats_desc; + struct kvm_stats_header *kvm_stats_header; + size_t size_desc; + ssize_t ret; + + switch (target) { + case STATS_TARGET_VM: + ident =3D StatsTarget_str(STATS_TARGET_VM); + break; + case STATS_TARGET_VCPU: + ident =3D current_cpu->parent_obj.canonical_path; + break; + default: + abort(); + } + + QTAILQ_FOREACH(descriptors, &stats_descriptors, next) { + if (g_str_equal(descriptors->ident, ident)) { + return descriptors; + } + } + + descriptors =3D g_new0(StatsDescriptors, 1); + + /* Read stats header */ + kvm_stats_header =3D g_malloc(sizeof(*kvm_stats_header)); + ret =3D read(stats_fd, kvm_stats_header, sizeof(*kvm_stats_header)); + if (ret !=3D sizeof(*kvm_stats_header)) { + error_setg(errp, "KVM stats: failed to read stats header: " + "expected %zu actual %zu", + sizeof(*kvm_stats_header), ret); + return NULL; + } + size_desc =3D sizeof(*kvm_stats_desc) + kvm_stats_header->name_size; + + /* Read stats descriptors */ + kvm_stats_desc =3D g_malloc0_n(kvm_stats_header->num_desc, size_desc); + ret =3D pread(stats_fd, kvm_stats_desc, + size_desc * kvm_stats_header->num_desc, + kvm_stats_header->desc_offset); + + if (ret !=3D size_desc * kvm_stats_header->num_desc) { + error_setg(errp, "KVM stats: failed to read stats descriptors: " + "expected %zu actual %zu", + size_desc * kvm_stats_header->num_desc, ret); + g_free(descriptors); + return NULL; + } + descriptors->kvm_stats_header =3D kvm_stats_header; + descriptors->kvm_stats_desc =3D kvm_stats_desc; + descriptors->ident =3D g_strdup(ident); + QTAILQ_INSERT_TAIL(&stats_descriptors, descriptors, next); + return descriptors; +} + +static void query_stats(StatsResultList **result, StatsTarget target, + int stats_fd, Error **errp) +{ + struct kvm_stats_desc *kvm_stats_desc; + struct kvm_stats_header *kvm_stats_header; + StatsDescriptors *descriptors; + g_autofree uint64_t *stats_data =3D NULL; + struct kvm_stats_desc *pdesc; + StatsList *stats_list =3D NULL; + size_t size_desc, size_data =3D 0; + ssize_t ret; + int i; + + descriptors =3D find_stats_descriptors(target, stats_fd, errp); + if (!descriptors) { + return; + } + + kvm_stats_header =3D descriptors->kvm_stats_header; + kvm_stats_desc =3D descriptors->kvm_stats_desc; + size_desc =3D sizeof(*kvm_stats_desc) + kvm_stats_header->name_size; + + /* Tally the total data size; read schema data */ + for (i =3D 0; i < kvm_stats_header->num_desc; ++i) { + pdesc =3D (void *)kvm_stats_desc + i * size_desc; + size_data +=3D pdesc->size * sizeof(*stats_data); + } + + stats_data =3D g_malloc0(size_data); + ret =3D pread(stats_fd, stats_data, size_data, kvm_stats_header->data_= offset); + + if (ret !=3D size_data) { + error_setg(errp, "KVM stats: failed to read data: " + "expected %zu actual %zu", size_data, ret); + return; + } + + for (i =3D 0; i < kvm_stats_header->num_desc; ++i) { + uint64_t *stats; + pdesc =3D (void *)kvm_stats_desc + i * size_desc; + + /* Add entry to the list */ + stats =3D (void *)stats_data + pdesc->offset; + stats_list =3D add_kvmstat_entry(pdesc, stats, stats_list, errp); + } + + if (!stats_list) { + return; + } + + switch (target) { + case STATS_TARGET_VM: + add_stats_entry(result, STATS_PROVIDER_KVM, NULL, stats_list); + break; + case STATS_TARGET_VCPU: + add_stats_entry(result, STATS_PROVIDER_KVM, + current_cpu->parent_obj.canonical_path, + stats_list); + break; + default: + break; + } +} + +static void query_stats_schema(StatsSchemaList **result, StatsTarget targe= t, + int stats_fd, Error **errp) +{ + struct kvm_stats_desc *kvm_stats_desc; + struct kvm_stats_header *kvm_stats_header; + StatsDescriptors *descriptors; + struct kvm_stats_desc *pdesc; + StatsSchemaValueList *stats_list =3D NULL; + size_t size_desc; + int i; + + descriptors =3D find_stats_descriptors(target, stats_fd, errp); + if (!descriptors) { + return; + } + + kvm_stats_header =3D descriptors->kvm_stats_header; + kvm_stats_desc =3D descriptors->kvm_stats_desc; + size_desc =3D sizeof(*kvm_stats_desc) + kvm_stats_header->name_size; + + /* Tally the total data size; read schema data */ + for (i =3D 0; i < kvm_stats_header->num_desc; ++i) { + pdesc =3D (void *)kvm_stats_desc + i * size_desc; + stats_list =3D add_kvmschema_entry(pdesc, stats_list, errp); + } + + add_stats_schema(result, STATS_PROVIDER_KVM, target, stats_list); +} + +static void query_stats_vcpu(CPUState *cpu, run_on_cpu_data data) +{ + StatsArgs *kvm_stats_args =3D (StatsArgs *) data.host_ptr; + int stats_fd =3D kvm_vcpu_ioctl(cpu, KVM_GET_STATS_FD, NULL); + Error *local_err =3D NULL; + + if (stats_fd =3D=3D -1) { + error_setg(&local_err, "KVM stats: ioctl failed"); + error_propagate(kvm_stats_args->errp, local_err); + return; + } + query_stats(kvm_stats_args->result.stats, STATS_TARGET_VCPU, stats_fd, + kvm_stats_args->errp); + close(stats_fd); +} + +static void query_stats_schema_vcpu(CPUState *cpu, run_on_cpu_data data) +{ + StatsArgs *kvm_stats_args =3D (StatsArgs *) data.host_ptr; + int stats_fd =3D kvm_vcpu_ioctl(cpu, KVM_GET_STATS_FD, NULL); + Error *local_err =3D NULL; + + if (stats_fd =3D=3D -1) { + error_setg(&local_err, "KVM stats: ioctl failed"); + error_propagate(kvm_stats_args->errp, local_err); + return; + } + query_stats_schema(kvm_stats_args->result.schema, STATS_TARGET_VCPU, s= tats_fd, + kvm_stats_args->errp); + close(stats_fd); +} + +static void query_stats_cb(StatsResultList **result, StatsTarget target, E= rror **errp) +{ + KVMState *s =3D kvm_state; + CPUState *cpu; + int stats_fd; + + switch (target) { + case STATS_TARGET_VM: + { + stats_fd =3D kvm_vm_ioctl(s, KVM_GET_STATS_FD, NULL); + if (stats_fd =3D=3D -1) { + error_setg(errp, "KVM stats: ioctl failed"); + return; + } + query_stats(result, target, stats_fd, errp); + close(stats_fd); + break; + } + case STATS_TARGET_VCPU: + { + StatsArgs stats_args; + stats_args.result.stats =3D result; + stats_args.errp =3D errp; + CPU_FOREACH(cpu) { + run_on_cpu(cpu, query_stats_vcpu, RUN_ON_CPU_HOST_PTR(&stats_a= rgs)); + } + break; + } + default: + break; + } +} + +void query_stats_schemas_cb(StatsSchemaList **result, Error **errp) +{ + StatsArgs stats_args; + KVMState *s =3D kvm_state; + int stats_fd; + + stats_fd =3D kvm_vm_ioctl(s, KVM_GET_STATS_FD, NULL); + if (stats_fd =3D=3D -1) { + error_setg(errp, "KVM stats: ioctl failed"); + return; + } + query_stats_schema(result, STATS_TARGET_VM, stats_fd, errp); + close(stats_fd); + + stats_args.result.schema =3D result; + stats_args.errp =3D errp; + run_on_cpu(first_cpu, query_stats_schema_vcpu, RUN_ON_CPU_HOST_PTR(&st= ats_args)); +} diff --git a/qapi/stats.json b/qapi/stats.json index 7454dd7daa..bcc897258a 100644 --- a/qapi/stats.json +++ b/qapi/stats.json @@ -50,7 +50,7 @@ # Since: 7.1 ## { 'enum': 'StatsProvider', - 'data': [ ] } + 'data': [ 'kvm' ] } =20 ## # @StatsTarget: --=20 2.35.1 From nobody Mon Feb 9 19:55:42 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1650982846161565.5825291717772; Tue, 26 Apr 2022 07:20:46 -0700 (PDT) Received: from localhost ([::1]:50100 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1njM3Z-0004za-05 for importer@patchew.org; Tue, 26 Apr 2022 10:20:45 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:38168) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1njLzP-0005RQ-Pr for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:27 -0400 Received: from mail-wm1-x32c.google.com ([2a00:1450:4864:20::32c]:55263) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1njLzN-0005WG-BB for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:27 -0400 Received: by mail-wm1-x32c.google.com with SMTP id bg25so10591064wmb.4 for ; Tue, 26 Apr 2022 07:16:24 -0700 (PDT) Received: from avogadro.lan ([2001:b07:6468:f312:e3ec:5559:7c5c:1928]) by smtp.gmail.com with ESMTPSA id o6-20020a05600c378600b0038eca3cdbb3sm11206464wmr.13.2022.04.26.07.16.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 26 Apr 2022 07:16:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=blltVQxUfRMgB02brI2aMVLkDz9/5gETTf5irezxr4g=; b=jyS6MNO2bFiEUa8xFdvU+st823skqoviXfpDe6BUZKj+1CvcUYwlFbi8xZd0fXh8Jp bCQ2QFpDBGI7Q8dmZUHk4Udjghv2dPhKfUZsgUbtcdc4VtoumMvggoM4HGZmgaM+BfCk DDTt7UICEVjjLgddrJ5CdJznPLQqhGscaoCTHdTTb5jzGkpWeVuRX0sF192VPY6i0g0W UZit3ry2DH7uSp7rS8/+/f0AR69iPzfLPjTSxras0SWFYneXioFGNfG36djgAp88sJUD j45eERfyV2Nyvt4+Uk+A5feuuUD7BxlSYjHf8j8fSEBdLiPhNXffvCrXsCdBiqPvyUZt yTTA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-transfer-encoding; bh=blltVQxUfRMgB02brI2aMVLkDz9/5gETTf5irezxr4g=; b=WVngQP3cfWVE1n+9U81gxHYHVba/UNSI8sBH1RCacSMA3gAJbkdUpZnfBuPBPPAJq8 UIXz+Uitih+qGw7k26Z1HHb4zSdQzrWN5P71c92gmQA8/EVrfCKFMHaaRrJ24cEYMAtr Kv2JcwWb0sn9Nx8zFHFGApQ5gGXEVLkD1Hb7rz4IKB1nnUCePGgsqrERKBsfPzIpNmIi Ymb9AUSSZY4q7foc/jQRGo7F6YtNNR+atkJMDCpfUSIP+YBh8P96W08dU9TXqoV7EQsp 0LtaMBAGKMzqX4utwldL3A7xKaHbiOWYqunGwitPqcKtcVHFTthdPdZ7qk38HDcTM5xV UTjQ== X-Gm-Message-State: AOAM533uU9uvPikZm5VeJeDnFRZxdnPgnPw6YGQ58oAWI13T7tIbGB3Y vyWlU0WptvL+LltRDfBijrxJuL49aYAi0A== X-Google-Smtp-Source: ABdhPJxhtYgS3c4Lz8CeGRlkzlLlbOdZSH5o/EuGwlhT29TlX1MWsbK6hjeqHdbmLhq3MCYdM5gV5A== X-Received: by 2002:a05:600c:1d8b:b0:38e:c518:ccc4 with SMTP id p11-20020a05600c1d8b00b0038ec518ccc4mr21762775wms.54.1650982584042; Tue, 26 Apr 2022 07:16:24 -0700 (PDT) From: Paolo Bonzini To: qemu-devel@nongnu.org Subject: [PATCH 3/8] qmp: add filtering of statistics by target vCPU Date: Tue, 26 Apr 2022 16:16:14 +0200 Message-Id: <20220426141619.304611-4-pbonzini@redhat.com> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220426141619.304611-1-pbonzini@redhat.com> References: <20220426141619.304611-1-pbonzini@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::32c; envelope-from=paolo.bonzini@gmail.com; helo=mail-wm1-x32c.google.com X-Spam_score_int: -14 X-Spam_score: -1.5 X-Spam_bar: - X-Spam_report: (-1.5 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FORGED_FROMDOMAIN=0.249, FREEMAIL_FROM=0.001, HEADER_FROM_DIFFERENT_DOMAINS=0.249, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: berrange@redhat.com, armbru@redhat.com, dgilbert@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZM-MESSAGEID: 1650982847471100002 Content-Type: text/plain; charset="utf-8" Introduce a simple filtering of statistics, that allows to retrieve statistics for a subset of the guest vCPUs. This will be used for example by the HMP monitor, in order to retrieve the statistics for the currently selected CPU. Example: { "execute": "query-stats", "arguments": { "target": "vcpu", "vcpus": [ "/machine/unattached/device[2]", "/machine/unattached/device[4]" ] } } Extracted from a patch by Mark Kanda. Signed-off-by: Paolo Bonzini --- accel/kvm/kvm-all.c | 9 +++++++-- include/monitor/stats.h | 9 ++++++++- monitor/qmp-cmds.c | 34 +++++++++++++++++++++++++++++++++- qapi/stats.json | 16 ++++++++++++++-- 4 files changed, 62 insertions(+), 6 deletions(-) diff --git a/accel/kvm/kvm-all.c b/accel/kvm/kvm-all.c index 4a753d4445..bfd81039a1 100644 --- a/accel/kvm/kvm-all.c +++ b/accel/kvm/kvm-all.c @@ -2311,7 +2311,8 @@ bool kvm_dirty_ring_enabled(void) return kvm_state->kvm_dirty_ring_size ? true : false; } =20 -static void query_stats_cb(StatsResultList **result, StatsTarget target, E= rror **errp); +static void query_stats_cb(StatsResultList **result, StatsTarget target, + strList *targets, Error **errp); static void query_stats_schemas_cb(StatsSchemaList **result, Error **errp); =20 static int kvm_init(MachineState *ms) @@ -4049,7 +4050,8 @@ static void query_stats_schema_vcpu(CPUState *cpu, ru= n_on_cpu_data data) close(stats_fd); } =20 -static void query_stats_cb(StatsResultList **result, StatsTarget target, E= rror **errp) +static void query_stats_cb(StatsResultList **result, StatsTarget target, + strList *targets, Error **errp) { KVMState *s =3D kvm_state; CPUState *cpu; @@ -4073,6 +4075,9 @@ static void query_stats_cb(StatsResultList **result, = StatsTarget target, Error * stats_args.result.stats =3D result; stats_args.errp =3D errp; CPU_FOREACH(cpu) { + if (!str_in_list(cpu->parent_obj.canonical_path, targets)) { + continue; + } run_on_cpu(cpu, query_stats_vcpu, RUN_ON_CPU_HOST_PTR(&stats_a= rgs)); } break; diff --git a/include/monitor/stats.h b/include/monitor/stats.h index 89552ab06f..92a1df3072 100644 --- a/include/monitor/stats.h +++ b/include/monitor/stats.h @@ -10,7 +10,8 @@ =20 #include "qapi/qapi-types-stats.h" =20 -typedef void StatRetrieveFunc(StatsResultList **result, StatsTarget target= , Error **errp); +typedef void StatRetrieveFunc(StatsResultList **result, StatsTarget target, + strList *targets, Error **errp); typedef void SchemaRetrieveFunc(StatsSchemaList **result, Error **errp); =20 /* @@ -30,4 +31,10 @@ void add_stats_entry(StatsResultList **, StatsProvider, = const char *id, void add_stats_schema(StatsSchemaList **, StatsProvider, StatsTarget, StatsSchemaValueList *); =20 +/* + * True if a string matches the filter passed to the stats_fn callabck, + * false otherwise. + */ +bool str_in_list(const char *string, strList *list); + #endif /* STATS_H */ diff --git a/monitor/qmp-cmds.c b/monitor/qmp-cmds.c index 97825b25fa..5e3f4c9685 100644 --- a/monitor/qmp-cmds.c +++ b/monitor/qmp-cmds.c @@ -448,13 +448,30 @@ void add_stats_callbacks(StatRetrieveFunc *stats_fn, QTAILQ_INSERT_TAIL(&stats_callbacks, entry, next); } =20 +static strList *stats_target_filter(StatsFilter *filter) +{ + switch (filter->target) { + case STATS_TARGET_VM: + return NULL; + case STATS_TARGET_VCPU: + if (!filter->u.vcpu.has_vcpus) { + return NULL; + } + return filter->u.vcpu.vcpus; + break; + default: + abort(); + } +} + StatsResultList *qmp_query_stats(StatsFilter *filter, Error **errp) { StatsResultList *stats_results =3D NULL; + strList *targets =3D stats_target_filter(filter); StatsCallbacks *entry; =20 QTAILQ_FOREACH(entry, &stats_callbacks, next) { - entry->stats_cb(&stats_results, filter->target, errp); + entry->stats_cb(&stats_results, filter->target, targets, errp); } =20 return stats_results; @@ -497,3 +514,18 @@ void add_stats_schema(StatsSchemaList **schema_results, entry->stats =3D stats_list; QAPI_LIST_PREPEND(*schema_results, entry); } + +bool str_in_list(const char *string, strList *list) +{ + strList *str_list =3D NULL; + + if (!list) { + return true; + } + for (str_list =3D list; str_list; str_list =3D str_list->next) { + if (g_str_equal(string, str_list->value)) { + return true; + } + } + return false; +} diff --git a/qapi/stats.json b/qapi/stats.json index bcc897258a..26ee69588f 100644 --- a/qapi/stats.json +++ b/qapi/stats.json @@ -65,6 +65,16 @@ { 'enum': 'StatsTarget', 'data': [ 'vm', 'vcpu' ] } =20 +## +# @StatsVCPUFilter: +# +# @vcpus: list of qom paths for the desired vCPU objects. +# +# Since: 7.1 +## +{ 'struct': 'StatsVCPUFilter', + 'data': { '*vcpus': [ 'str' ] } } + ## # @StatsFilter: # @@ -73,8 +83,10 @@ # # Since: 7.1 ## -{ 'struct': 'StatsFilter', - 'data': { 'target': 'StatsTarget' } } +{ 'union': 'StatsFilter', + 'base': { 'target': 'StatsTarget' }, + 'discriminator': 'target', + 'data': { 'vcpu': 'StatsVCPUFilter' } } =20 ## # @StatsValue: --=20 2.35.1 From nobody Mon Feb 9 19:55:42 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1650982987158747.1601951278058; Tue, 26 Apr 2022 07:23:07 -0700 (PDT) Received: from localhost ([::1]:57126 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1njM5p-0001LU-M5 for importer@patchew.org; Tue, 26 Apr 2022 10:23:05 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:38184) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1njLzQ-0005SI-JC for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:29 -0400 Received: from mail-wm1-x332.google.com ([2a00:1450:4864:20::332]:34088) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1njLzO-0005WP-L1 for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:28 -0400 Received: by mail-wm1-x332.google.com with SMTP id ay36-20020a05600c1e2400b0038ebc885115so1145169wmb.1 for ; Tue, 26 Apr 2022 07:16:26 -0700 (PDT) Received: from avogadro.lan ([2001:b07:6468:f312:e3ec:5559:7c5c:1928]) by smtp.gmail.com with ESMTPSA id o6-20020a05600c378600b0038eca3cdbb3sm11206464wmr.13.2022.04.26.07.16.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 26 Apr 2022 07:16:24 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=5M7XvC3bPFfoEdkPyYqPTJxbw77vg1qcVegS2S1ATho=; b=MF3ASCG9DSAX12wprVT5Q9z2ifcirq0sh9ihRMpodK2ZwAMuRJBXfJpVAFbj9D2WoD BBGatJjmBIuYvb4ko7IY4Z2FO/VzDl3NNoKejGVJYIFrbjcCT0KYElPKuXV2rsh2QUZr f0PeShervjzvTnUnlhrtoRc5UPrs5PiqEU3d5SHFByH/4szTIslAMr6KqETFv9FyLLCF yzfEpiiFH+voJTnQ40DzXN9d+um3xznapZ59P+APLZBrISUNBKfY2sziJ/Otasy8jcCO ojcVTudSQeZynGlKdjYrNmtRKZmaJuSb8LkRSWNt5ihIoWCFcKOjc54Sij8ID6jHHBR5 O03w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-transfer-encoding; bh=5M7XvC3bPFfoEdkPyYqPTJxbw77vg1qcVegS2S1ATho=; b=tm2h259CxD7SrSVthhPmc9/hRHcL0Dqdv+MapLaUBKNYJMuEK5wOCAhBxR9CYjVy3+ 2sD0jSsT60NacQpYBx2g14mfJFdG7TvoA//6RomQ3Fs+C1LRWa8ngmX80ahD82VOoxPt cVhggyIalVtOhnZzyg6dS+0ECszFjZ41vV7iyI4uKMaeUnQ3kuU/yZqmCxpCTQTU/Abg +KHwm08D6oxlBv0tSrVQI4z5xcIJYVmdRhksS64X/1HEOUO2EaTKZorXZACfeROCA2LK M9nZZzKURWmmRyDiKlp1AT7TdqX32rkrSGPLb8tXpGDtBQkWy9b9fYqupRElMY0t3pXk qy+Q== X-Gm-Message-State: AOAM533owMq9W7KdHOsBfT+go5QV0bcHMI2aA9uEnz5ytvH4b+hyPWUV MCCYCop1KVitMSCYHg+Jvuwoag/sh1CJ0Q== X-Google-Smtp-Source: ABdhPJwjTfCq1mdtcXxBWUrbZfhbgROZUrOjTYDLp6Y+Z7PeS/1P4vDwE5WL1lmMHW4OABiBztjsNQ== X-Received: by 2002:a7b:cbd3:0:b0:38e:bc95:5048 with SMTP id n19-20020a7bcbd3000000b0038ebc955048mr21302974wmi.203.1650982585270; Tue, 26 Apr 2022 07:16:25 -0700 (PDT) From: Paolo Bonzini To: qemu-devel@nongnu.org Subject: [PATCH 4/8] hmp: add basic "info stats" implementation Date: Tue, 26 Apr 2022 16:16:15 +0200 Message-Id: <20220426141619.304611-5-pbonzini@redhat.com> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220426141619.304611-1-pbonzini@redhat.com> References: <20220426141619.304611-1-pbonzini@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::332; envelope-from=paolo.bonzini@gmail.com; helo=mail-wm1-x332.google.com X-Spam_score_int: -14 X-Spam_score: -1.5 X-Spam_bar: - X-Spam_report: (-1.5 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FORGED_FROMDOMAIN=0.249, FREEMAIL_FROM=0.001, HEADER_FROM_DIFFERENT_DOMAINS=0.249, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: berrange@redhat.com, armbru@redhat.com, dgilbert@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZM-MESSAGEID: 1650982988667100002 Content-Type: text/plain; charset="utf-8" From: Mark Kanda Add an HMP command to retrieve statistics collected at run-time. The command will retrieve and print either all VM-level statistics, or all vCPU-level statistics for the currently selected CPU. Signed-off-by: Paolo Bonzini --- hmp-commands-info.hx | 13 +++ include/monitor/hmp.h | 1 + monitor/hmp-cmds.c | 189 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 203 insertions(+) diff --git a/hmp-commands-info.hx b/hmp-commands-info.hx index adfa085a9b..221feab8c0 100644 --- a/hmp-commands-info.hx +++ b/hmp-commands-info.hx @@ -894,3 +894,16 @@ SRST ``info via`` Show guest mos6522 VIA devices. ERST + + { + .name =3D "stats", + .args_type =3D "target:s", + .params =3D "target", + .help =3D "show statistics; target is either vm or vcpu", + .cmd =3D hmp_info_stats, + }, + +SRST + ``stats`` + Show runtime-collected statistics +ERST diff --git a/include/monitor/hmp.h b/include/monitor/hmp.h index 96d014826a..2e89a97bd6 100644 --- a/include/monitor/hmp.h +++ b/include/monitor/hmp.h @@ -133,5 +133,6 @@ void hmp_info_dirty_rate(Monitor *mon, const QDict *qdi= ct); void hmp_calc_dirty_rate(Monitor *mon, const QDict *qdict); void hmp_human_readable_text_helper(Monitor *mon, HumanReadableText *(*qmp_handler)(Erro= r **)); +void hmp_info_stats(Monitor *mon, const QDict *qdict); =20 #endif diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c index d8b98bed6c..1ac00ba124 100644 --- a/monitor/hmp-cmds.c +++ b/monitor/hmp-cmds.c @@ -40,6 +40,7 @@ #include "qapi/qapi-commands-pci.h" #include "qapi/qapi-commands-rocker.h" #include "qapi/qapi-commands-run-state.h" +#include "qapi/qapi-commands-stats.h" #include "qapi/qapi-commands-tpm.h" #include "qapi/qapi-commands-ui.h" #include "qapi/qapi-visit-net.h" @@ -52,6 +53,7 @@ #include "ui/console.h" #include "qemu/cutils.h" #include "qemu/error-report.h" +#include "hw/core/cpu.h" #include "hw/intc/intc.h" #include "migration/snapshot.h" #include "migration/misc.h" @@ -2223,3 +2225,190 @@ void hmp_info_memory_size_summary(Monitor *mon, con= st QDict *qdict) } hmp_handle_error(mon, err); } + +static void print_stats_schema_value(Monitor *mon, StatsSchemaValue *value) +{ + const char *prefix =3D ""; + monitor_printf(mon, " %s (%s", value->name, StatsType_str(value->ty= pe)); + + if (value->has_unit && value->unit =3D=3D STATS_UNIT_SECONDS && + (value->exponent =3D=3D 0 || value->base =3D=3D 10) && + value->exponent >=3D -9 && value->exponent <=3D 0 && + value->exponent % 3 =3D=3D 0) { + + static const char *si_prefix[] =3D { "", "milli", "micro", "nano" = }; + prefix =3D si_prefix[value->exponent / -3]; + + } else if (value->has_unit && value->unit =3D=3D STATS_UNIT_BYTES && + (value->exponent =3D=3D 0 || value->base =3D=3D 2) && + value->exponent >=3D 0 && value->exponent <=3D 40 && + value->exponent % 10 =3D=3D 0) { + + static const char *si_prefix[] =3D { + "", "kilo", "mega", "giga", "tera" }; + prefix =3D si_prefix[value->exponent / 10]; + + } else if (value->exponent) { + /* Print the base and exponent as "x ^" */ + monitor_printf(mon, ", * %d^%d", value->base, + value->exponent); + } + + if (value->has_unit) { + monitor_printf(mon, " %s%s", prefix, StatsUnit_str(value->unit)); + } + + /* Print bucket size for linear histograms */ + if (value->type =3D=3D STATS_TYPE_LINEAR_HIST && value->has_bucket_siz= e) { + monitor_printf(mon, ", bucket size=3D%d", value->bucket_size); + } + monitor_printf(mon, ")"); +} + +static StatsSchemaValueList *find_schema_value_list( + StatsSchemaList *list, StatsProvider provider, + StatsTarget target) +{ + StatsSchemaList *node; + + for (node =3D list; node; node =3D node->next) { + if (node->value->provider =3D=3D provider && + node->value->target =3D=3D target) { + return node->value->stats; + } + } + return NULL; +} + +static void print_stats_results(Monitor *mon, StatsTarget target, + StatsResult *result, + StatsSchemaList *schema) +{ + /* Find provider schema */ + StatsSchemaValueList *schema_value_list =3D + find_schema_value_list(schema, result->provider, target); + StatsList *stats_list; + + if (!schema_value_list) { + monitor_printf(mon, "failed to find schema list for %s\n", + StatsProvider_str(result->provider)); + return; + } + + monitor_printf(mon, "provider: %s\n", + StatsProvider_str(result->provider)); + + for (stats_list =3D result->stats; stats_list; + stats_list =3D stats_list->next, + schema_value_list =3D schema_value_list->next) { + + Stats *stats =3D stats_list->value; + StatsValue *stats_value =3D stats->value; + StatsSchemaValue *schema_value =3D schema_value_list->value; + + /* Find schema entry */ + while (!g_str_equal(stats->name, schema_value->name)) { + if (!schema_value_list->next) { + monitor_printf(mon, "failed to find schema entry for %s\n", + stats->name); + return; + } + schema_value_list =3D schema_value_list->next; + schema_value =3D schema_value_list->value; + } + + print_stats_schema_value(mon, schema_value); + + if (stats_value->type =3D=3D QTYPE_QNUM) { + monitor_printf(mon, ": %" PRId64 "\n", stats_value->u.scalar); + } else if (stats_value->type =3D=3D QTYPE_QLIST) { + uint64List *list; + int i; + + monitor_printf(mon, ": "); + for (list =3D stats_value->u.list, i =3D 1; + list; + list =3D list->next, i++) { + monitor_printf(mon, "[%d]=3D%" PRId64 " ", i, list->value); + } + monitor_printf(mon, "\n"); + } + } +} + +/* Create the StatsFilter that is needed for an "info stats" invocation. = */ +static StatsFilter *stats_filter(StatsTarget target, int cpu_index) +{ + StatsFilter *filter =3D g_malloc0(sizeof(*filter)); + + filter->target =3D target; + switch (target) { + case STATS_TARGET_VM: + break; + case STATS_TARGET_VCPU: + { + strList *vcpu_list =3D NULL; + CPUState *cpu =3D qemu_get_cpu(cpu_index); + char *canonical_path =3D object_get_canonical_path(OBJECT(cpu)); + + QAPI_LIST_PREPEND(vcpu_list, canonical_path); + filter->u.vcpu.has_vcpus =3D true; + filter->u.vcpu.vcpus =3D vcpu_list; + break; + } + default: + break; + } + return filter; +} + +void hmp_info_stats(Monitor *mon, const QDict *qdict) +{ + const char *target_str =3D qdict_get_str(qdict, "target"); + StatsTarget target; + Error *err =3D NULL; + StatsResultList *stats =3D NULL; + StatsSchemaList *schema =3D NULL; + StatsFilter *filter =3D NULL; + + target =3D qapi_enum_parse(&StatsTarget_lookup, target_str, -1, &err); + if (err) { + monitor_printf(mon, "invalid stats target %s\n", target_str); + goto exit_no_print; + } + + schema =3D qmp_query_stats_schemas(&err); + if (err) { + goto exit; + } + + switch (target) { + case STATS_TARGET_VM: + filter =3D stats_filter(target, -1); + break; + case STATS_TARGET_VCPU: {} + int cpu_index =3D monitor_get_cpu_index(mon); + filter =3D stats_filter(target, cpu_index); + break; + default: + abort(); + } + + stats =3D qmp_query_stats(filter, &err); + if (err) { + goto exit; + } + if (stats) { + print_stats_results(mon, target, stats->value, schema); + } + qapi_free_StatsFilter(filter); + qapi_free_StatsSchemaList(schema); + qapi_free_StatsResultList(stats); + +exit: + if (err) { + monitor_printf(mon, "%s\n", error_get_pretty(err)); + } +exit_no_print: + error_free(err); +} --=20 2.35.1 From nobody Mon Feb 9 19:55:42 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1650982846142185.6629560335424; Tue, 26 Apr 2022 07:20:46 -0700 (PDT) Received: from localhost ([::1]:50216 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1njM3Z-00053z-5f for importer@patchew.org; Tue, 26 Apr 2022 10:20:45 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:38206) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1njLzR-0005SK-Ek for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:29 -0400 Received: from mail-wm1-x32a.google.com ([2a00:1450:4864:20::32a]:35336) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1njLzP-0005Wh-Nn for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:29 -0400 Received: by mail-wm1-x32a.google.com with SMTP id c190-20020a1c35c7000000b0038e37907b5bso1629380wma.0 for ; Tue, 26 Apr 2022 07:16:27 -0700 (PDT) Received: from avogadro.lan ([2001:b07:6468:f312:e3ec:5559:7c5c:1928]) by smtp.gmail.com with ESMTPSA id o6-20020a05600c378600b0038eca3cdbb3sm11206464wmr.13.2022.04.26.07.16.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 26 Apr 2022 07:16:25 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=q5ZWR4a9MyhZdY7QbLORjdQwhuCmA4Ze3zzZ+Jeh7gY=; b=XVGYH5kpZ6f+SWDjTjKOLxbEMHu9g4emoCE874YA6ZyDq8xqqJpXstzdpvNC4FxUV+ xsNcScc9LoGScpayJbe3lrbNbR/q+jYy40HKkMQerlEpuiQLDhTcggZaIDfiU4efetOJ n1z83cs85kQsDqOoMYosCiXx4i7ZOU93WiWcuLsZj1uh5n98g9mF+kw7QrZ+ZM8mUkz6 ZGBOn5EptOCVldfn+aYJGMUy64/N3Rzwf0HVq4R++h9hnLgKtLx+IzILfSHneNhEorsS /x7WwUuVedUV5VjBrPrK5w/Q58AdyZoY/J+dPGHQLUCdf9PXtyaeAoK0oUkVzGt7aAyP osZw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-transfer-encoding; bh=q5ZWR4a9MyhZdY7QbLORjdQwhuCmA4Ze3zzZ+Jeh7gY=; b=BETQlUkwE/7lWLcfYsM7fwjicUcdA898Phf0XbmsJ9m+bcktvKio9zROiv6cHB9+wV Tz5HNvT9SU3OyZSLsrprX6aW1dDm8vXtqZrdC673Aucyi/lEgCvSNPSJz2US43kQuLtY +djFgaLbHEMsEQiA1/vwP3Fc22SOQUruBD9UC8QJo2JP+cnWL4/W2hAl46sdXxP/UPuZ pkMTrIp8DpTRfpe8xs1E9bDr1kPjaZ9lbOGINMRqjJGocMi5QMX9kM6Rb0YdORyagBlO pENFvIF33/r+tofxUVduDbcUVPldlCsFlTYJYHR7TbZEKEA4ZyuyJc8ZI/XcD0H7XGir OpJA== X-Gm-Message-State: AOAM532IbvUcLq6RuDrdGKThivz7CtxjtL2m4QMHlz3dXnoVEkpyfAel h6tIbXBXIgwVV4bDni7XD4Htb5Tmu9/aMA== X-Google-Smtp-Source: ABdhPJwo+GSh2JzGHsA0w3+uRDh4M/tVM/mIQI6F7NBSwK4HbGCdhteNA1ADh4s/q+NCWmbNcrWe7A== X-Received: by 2002:a05:600c:35c6:b0:393:ebf0:d530 with SMTP id r6-20020a05600c35c600b00393ebf0d530mr9947235wmq.34.1650982586293; Tue, 26 Apr 2022 07:16:26 -0700 (PDT) From: Paolo Bonzini To: qemu-devel@nongnu.org Subject: [PATCH 5/8] qmp: add filtering of statistics by provider Date: Tue, 26 Apr 2022 16:16:16 +0200 Message-Id: <20220426141619.304611-6-pbonzini@redhat.com> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220426141619.304611-1-pbonzini@redhat.com> References: <20220426141619.304611-1-pbonzini@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::32a; envelope-from=paolo.bonzini@gmail.com; helo=mail-wm1-x32a.google.com X-Spam_score_int: -14 X-Spam_score: -1.5 X-Spam_bar: - X-Spam_report: (-1.5 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FORGED_FROMDOMAIN=0.249, FREEMAIL_FROM=0.001, HEADER_FROM_DIFFERENT_DOMAINS=0.249, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: berrange@redhat.com, armbru@redhat.com, dgilbert@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZM-MESSAGEID: 1650982847449100001 Content-Type: text/plain; charset="utf-8" Allow retrieving the statistics from a specific provider only. This can be used in the future by HMP commands such as "info sync-profile" or "info profile". The next patch also adds filter-by-provider capabilities to the HMP equivalent of query-stats, "info stats". Example: { "execute": "query-stats", "arguments": { "target": "vm", "providers": [ { "provider": "kvm" } ] } } The QAPI is a bit more verbose than just a list of StatsProvider, so that it can be subsequently extended with filtering of statistics by name. Extracted from a patch by Mark Kanda. Signed-off-by: Paolo Bonzini --- accel/kvm/kvm-all.c | 3 ++- include/monitor/stats.h | 4 +++- monitor/hmp-cmds.c | 2 +- monitor/qmp-cmds.c | 33 +++++++++++++++++++++++++++++---- qapi/stats.json | 16 ++++++++++++++-- 5 files changed, 49 insertions(+), 9 deletions(-) diff --git a/accel/kvm/kvm-all.c b/accel/kvm/kvm-all.c index bfd81039a1..b42008ac07 100644 --- a/accel/kvm/kvm-all.c +++ b/accel/kvm/kvm-all.c @@ -2644,7 +2644,8 @@ static int kvm_init(MachineState *ms) } =20 if (kvm_check_extension(kvm_state, KVM_CAP_BINARY_STATS_FD)) { - add_stats_callbacks(query_stats_cb, query_stats_schemas_cb); + add_stats_callbacks(STATS_PROVIDER_KVM, query_stats_cb, + query_stats_schemas_cb); } =20 return 0; diff --git a/include/monitor/stats.h b/include/monitor/stats.h index 92a1df3072..acfd975df9 100644 --- a/include/monitor/stats.h +++ b/include/monitor/stats.h @@ -17,10 +17,12 @@ typedef void SchemaRetrieveFunc(StatsSchemaList **resul= t, Error **errp); /* * Register callbacks for the QMP query-stats command. * + * @provider: stats provider * @stats_fn: routine to query stats: * @schema_fn: routine to query stat schemas: */ -void add_stats_callbacks(StatRetrieveFunc *stats_fn, +void add_stats_callbacks(StatsProvider provider, + StatRetrieveFunc *stats_fn, SchemaRetrieveFunc *schemas_fn); =20 /* diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c index 1ac00ba124..2085d88e7d 100644 --- a/monitor/hmp-cmds.c +++ b/monitor/hmp-cmds.c @@ -2377,7 +2377,7 @@ void hmp_info_stats(Monitor *mon, const QDict *qdict) goto exit_no_print; } =20 - schema =3D qmp_query_stats_schemas(&err); + schema =3D qmp_query_stats_schemas(false, 0, &err); if (err) { goto exit; } diff --git a/monitor/qmp-cmds.c b/monitor/qmp-cmds.c index 5e3f4c9685..25962d8bb4 100644 --- a/monitor/qmp-cmds.c +++ b/monitor/qmp-cmds.c @@ -430,6 +430,7 @@ HumanReadableText *qmp_x_query_irq(Error **errp) } =20 typedef struct StatsCallbacks { + StatsProvider provider; StatRetrieveFunc *stats_cb; SchemaRetrieveFunc *schemas_cb; QTAILQ_ENTRY(StatsCallbacks) next; @@ -438,10 +439,12 @@ typedef struct StatsCallbacks { static QTAILQ_HEAD(, StatsCallbacks) stats_callbacks =3D QTAILQ_HEAD_INITIALIZER(stats_callbacks); =20 -void add_stats_callbacks(StatRetrieveFunc *stats_fn, +void add_stats_callbacks(StatsProvider provider, + StatRetrieveFunc *stats_fn, SchemaRetrieveFunc *schemas_fn) { StatsCallbacks *entry =3D g_new(StatsCallbacks, 1); + entry->provider =3D provider; entry->stats_cb =3D stats_fn; entry->schemas_cb =3D schemas_fn; =20 @@ -464,6 +467,22 @@ static strList *stats_target_filter(StatsFilter *filte= r) } } =20 +static bool stats_provider_requested(StatsProvider provider, + StatsFilter *filter) +{ + StatsRequestList *request; + + if (!filter->has_providers) { + return true; + } + for (request =3D filter->providers; request; request =3D request->next= ) { + if (request->value->provider =3D=3D provider) { + return true; + } + } + return false; +} + StatsResultList *qmp_query_stats(StatsFilter *filter, Error **errp) { StatsResultList *stats_results =3D NULL; @@ -471,19 +490,25 @@ StatsResultList *qmp_query_stats(StatsFilter *filter,= Error **errp) StatsCallbacks *entry; =20 QTAILQ_FOREACH(entry, &stats_callbacks, next) { - entry->stats_cb(&stats_results, filter->target, targets, errp); + if (stats_provider_requested(entry->provider, filter)) { + entry->stats_cb(&stats_results, filter->target, targets, errp); + } } =20 return stats_results; } =20 -StatsSchemaList *qmp_query_stats_schemas(Error **errp) +StatsSchemaList *qmp_query_stats_schemas(bool has_provider, + StatsProvider provider, + Error **errp) { StatsSchemaList *stats_results =3D NULL; StatsCallbacks *entry; =20 QTAILQ_FOREACH(entry, &stats_callbacks, next) { - entry->schemas_cb(&stats_results, errp); + if (!has_provider || provider =3D=3D entry->provider) { + entry->schemas_cb(&stats_results, errp); + } } =20 return stats_results; diff --git a/qapi/stats.json b/qapi/stats.json index 26ee69588f..33ff6ea7a9 100644 --- a/qapi/stats.json +++ b/qapi/stats.json @@ -65,6 +65,18 @@ { 'enum': 'StatsTarget', 'data': [ 'vm', 'vcpu' ] } =20 +## +# @StatsRequest: +# +# Indicates a set of statistics that should be returned by query-stats. +# +# @provider: provider for which to return statistics. +# +# Since: 7.1 +## +{ 'struct': 'StatsRequest', + 'data': { 'provider': 'StatsProvider' } } + ## # @StatsVCPUFilter: # @@ -84,7 +96,7 @@ # Since: 7.1 ## { 'union': 'StatsFilter', - 'base': { 'target': 'StatsTarget' }, + 'base': { 'target': 'StatsTarget', '*providers': [ 'StatsRequest' = ] }, 'discriminator': 'target', 'data': { 'vcpu': 'StatsVCPUFilter' } } =20 @@ -200,5 +212,5 @@ # Since: 7.1 ## { 'command': 'query-stats-schemas', - 'data': { }, + 'data': { '*provider': 'StatsProvider' }, 'returns': [ 'StatsSchema' ] } --=20 2.35.1 From nobody Mon Feb 9 19:55:42 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1650982723137796.8112825798825; Tue, 26 Apr 2022 07:18:43 -0700 (PDT) Received: from localhost ([::1]:42562 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1njM1Z-0008RI-NU for importer@patchew.org; Tue, 26 Apr 2022 10:18:41 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:38218) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1njLzS-0005Tl-5y for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:30 -0400 Received: from mail-wm1-x329.google.com ([2a00:1450:4864:20::329]:38418) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1njLzQ-0005Wo-Gl for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:29 -0400 Received: by mail-wm1-x329.google.com with SMTP id 1-20020a05600c248100b00393fbf11a05so580406wms.3 for ; Tue, 26 Apr 2022 07:16:28 -0700 (PDT) Received: from avogadro.lan ([2001:b07:6468:f312:e3ec:5559:7c5c:1928]) by smtp.gmail.com with ESMTPSA id o6-20020a05600c378600b0038eca3cdbb3sm11206464wmr.13.2022.04.26.07.16.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 26 Apr 2022 07:16:26 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=YNwi7yiy0wJwLLwFYiA87411z8l8mI9z7jlr8cryUNk=; b=VjIUHyZ2I1BksECiKr/Gt1YbT31webuKXCIU21J2dx7v6ly97MneEBNBX+r0b3gLIr 9Tr8c+uMjU12z1e/c8huTAmiPDSUcBAjDuMOmors+VNNk1nojPpTMHqYS23hPLbnNe0u solgbeqbzE8Q0rMa4c+Fnz8MMA9oo6l1s1rM7LbZY5mdK2IztVM4x1EQ+7GV3Myqk7PU xeyr1wwgjE1Rx5p57BUBDZ/I9EjI2v+7p/5JJtgx1ZWeGgehGz6D5+avoRFqRVsT0WiE lP2gx7yi00dNnO/oMFTV00/swzbI1zqKc/bHN4+XjtfPTzwdVSFzl+ZfWh0Bu82JJWw3 CQOA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-transfer-encoding; bh=YNwi7yiy0wJwLLwFYiA87411z8l8mI9z7jlr8cryUNk=; b=OFZ+WrALHpHnbfbcBBcID2EBwv5ReoKRfoRYcHtu+ZbGKA6wfVAtQHJ2iuRfpmr5pB pLvPjf43vt3MYoK4+ycxLjcYQR9r3X9Hv6yW49+iXgXPPo3OFkVdYOqBHlmug7iKPJ/C G6QWB39Igfs1z/cXcNNXEB73d0xDgCEgwCvZvC1gHFT8qh+bpWEF9RQ5i17UWdM2INt3 rLhFJh4DqLQByPtFr8I3NB4dghbuJc/uZcM9h/L2bjZc9yi7oYQMJLtW6DexQw88JESS VQdS9tqEHUzoC3KI7epgERdy9tuKNmNX+idH9lZfKyPhc+pt3KxGea3nY5asfvoLzpAE u2Iw== X-Gm-Message-State: AOAM530aJOEM6piMcB2/L2HtXPbKF3WiUJp00sEW7eZPwZqel/Nejphq CTSG9YEQMC/OxFr1iIbloYqEDNqSIKZP2Q== X-Google-Smtp-Source: ABdhPJz18gTr1szt67NbKED4STTxycVo5GAXEQlxup6fl9bExgiPFqc039WlPgAtqgBh8NFMwKU75Q== X-Received: by 2002:a05:600c:5c8:b0:393:eba0:8ac7 with SMTP id p8-20020a05600c05c800b00393eba08ac7mr10000291wmd.108.1650982587102; Tue, 26 Apr 2022 07:16:27 -0700 (PDT) From: Paolo Bonzini To: qemu-devel@nongnu.org Subject: [PATCH 6/8] hmp: add filtering of statistics by provider Date: Tue, 26 Apr 2022 16:16:17 +0200 Message-Id: <20220426141619.304611-7-pbonzini@redhat.com> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220426141619.304611-1-pbonzini@redhat.com> References: <20220426141619.304611-1-pbonzini@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::329; envelope-from=paolo.bonzini@gmail.com; helo=mail-wm1-x329.google.com X-Spam_score_int: -14 X-Spam_score: -1.5 X-Spam_bar: - X-Spam_report: (-1.5 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FORGED_FROMDOMAIN=0.249, FREEMAIL_FROM=0.001, HEADER_FROM_DIFFERENT_DOMAINS=0.249, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: berrange@redhat.com, armbru@redhat.com, dgilbert@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZM-MESSAGEID: 1650982724422100007 Content-Type: text/plain; charset="utf-8" Allow the user to request statistics for a single provider of interest. Extracted from a patch by Mark Kanda. Signed-off-by: Paolo Bonzini --- hmp-commands-info.hx | 7 ++++--- monitor/hmp-cmds.c | 46 +++++++++++++++++++++++++++++++++++--------- 2 files changed, 41 insertions(+), 12 deletions(-) diff --git a/hmp-commands-info.hx b/hmp-commands-info.hx index 221feab8c0..1a3e16175f 100644 --- a/hmp-commands-info.hx +++ b/hmp-commands-info.hx @@ -897,9 +897,10 @@ ERST =20 { .name =3D "stats", - .args_type =3D "target:s", - .params =3D "target", - .help =3D "show statistics; target is either vm or vcpu", + .args_type =3D "target:s,provider:s?", + .params =3D "target [provider]", + .help =3D "show statistics for the given target (vm or vcpu)= ; optionally filter by " + "provider", .cmd =3D hmp_info_stats, }, =20 diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c index 2085d88e7d..2bce9d7016 100644 --- a/monitor/hmp-cmds.c +++ b/monitor/hmp-cmds.c @@ -2281,6 +2281,7 @@ static StatsSchemaValueList *find_schema_value_list( } =20 static void print_stats_results(Monitor *mon, StatsTarget target, + bool show_provider, StatsResult *result, StatsSchemaList *schema) { @@ -2295,8 +2296,10 @@ static void print_stats_results(Monitor *mon, StatsT= arget target, return; } =20 - monitor_printf(mon, "provider: %s\n", - StatsProvider_str(result->provider)); + if (show_provider) { + monitor_printf(mon, "provider: %s\n", + StatsProvider_str(result->provider)); + } =20 for (stats_list =3D result->stats; stats_list; stats_list =3D stats_list->next, @@ -2337,7 +2340,8 @@ static void print_stats_results(Monitor *mon, StatsTa= rget target, } =20 /* Create the StatsFilter that is needed for an "info stats" invocation. = */ -static StatsFilter *stats_filter(StatsTarget target, int cpu_index) +static StatsFilter *stats_filter(StatsTarget target, int cpu_index, + StatsProvider provider) { StatsFilter *filter =3D g_malloc0(sizeof(*filter)); =20 @@ -2359,15 +2363,31 @@ static StatsFilter *stats_filter(StatsTarget target= , int cpu_index) default: break; } + + if (provider =3D=3D STATS_PROVIDER__MAX) { + return filter; + } + + /* "info stats" can only query either one or all the providers. */ + StatsRequest *request =3D g_new0(StatsRequest, 1); + request->provider =3D provider; + StatsRequestList *request_list =3D g_new0(StatsRequestList, 1); + QAPI_LIST_PREPEND(request_list, request); + filter->has_providers =3D true; + filter->providers =3D request_list; return filter; } =20 void hmp_info_stats(Monitor *mon, const QDict *qdict) { const char *target_str =3D qdict_get_str(qdict, "target"); + const char *provider_str =3D qdict_get_try_str(qdict, "provider"); + + StatsProvider provider =3D STATS_PROVIDER__MAX; StatsTarget target; Error *err =3D NULL; StatsResultList *stats =3D NULL; + StatsResultList *entry; StatsSchemaList *schema =3D NULL; StatsFilter *filter =3D NULL; =20 @@ -2376,19 +2396,27 @@ void hmp_info_stats(Monitor *mon, const QDict *qdic= t) monitor_printf(mon, "invalid stats target %s\n", target_str); goto exit_no_print; } + if (provider_str) { + provider =3D qapi_enum_parse(&StatsProvider_lookup, provider_str, = -1, &err); + if (err) { + monitor_printf(mon, "invalid stats provider %s\n", provider_st= r); + goto exit_no_print; + } + } =20 - schema =3D qmp_query_stats_schemas(false, 0, &err); + schema =3D qmp_query_stats_schemas(provider_str ? true : false, + provider, &err); if (err) { goto exit; } =20 switch (target) { case STATS_TARGET_VM: - filter =3D stats_filter(target, -1); - break; + filter =3D stats_filter(target, -1, provider); + break; case STATS_TARGET_VCPU: {} int cpu_index =3D monitor_get_cpu_index(mon); - filter =3D stats_filter(target, cpu_index); + filter =3D stats_filter(target, cpu_index, provider); break; default: abort(); @@ -2398,8 +2426,8 @@ void hmp_info_stats(Monitor *mon, const QDict *qdict) if (err) { goto exit; } - if (stats) { - print_stats_results(mon, target, stats->value, schema); + for (entry =3D stats; entry; entry =3D entry->next) { + print_stats_results(mon, target, provider_str =3D=3D NULL, entry->= value, schema); } qapi_free_StatsFilter(filter); qapi_free_StatsSchemaList(schema); --=20 2.35.1 From nobody Mon Feb 9 19:55:42 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1650982722138243.6882955119238; Tue, 26 Apr 2022 07:18:42 -0700 (PDT) Received: from localhost ([::1]:42404 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1njM1Z-0008Lb-4S for importer@patchew.org; Tue, 26 Apr 2022 10:18:41 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:38232) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1njLzS-0005VN-Um for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:31 -0400 Received: from mail-wm1-x32c.google.com ([2a00:1450:4864:20::32c]:52190) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1njLzR-0005XC-7H for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:30 -0400 Received: by mail-wm1-x32c.google.com with SMTP id q20so11306849wmq.1 for ; Tue, 26 Apr 2022 07:16:28 -0700 (PDT) Received: from avogadro.lan ([2001:b07:6468:f312:e3ec:5559:7c5c:1928]) by smtp.gmail.com with ESMTPSA id o6-20020a05600c378600b0038eca3cdbb3sm11206464wmr.13.2022.04.26.07.16.27 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 26 Apr 2022 07:16:27 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=xAT2NmAOUeByJ+TmZzvBSZ4oQ+VvE5Og9SzgEmZjzAw=; b=f7+eYTjDoItH2unp04LGAHPILFVzF0K7dIVBxPgGedgIin1DPrX6qrL3rzMXOYpL6m 1uz0TW9nBkg6aOr8SCvVfwkYqHFhlXEBWRov7ni6TlLUMS6bM/Bj4B8CE8ZLeUPv06+B ZEPt63R4Vx4PztxYfWN/ZixLJ6u6/cCfeuyluWHM9WPOTPIldnDwU1hTQHqeV7tikarz rDc2dDOChrESqMO+gk6eD9F2DkZFjDiLLZNbWiG+KdsWh76VhmxxuZN/h5mbOdqp7u89 hF/++NW3BZtyWxvXvFC+1wgybHnYyfzcsypjgjNzO0kPdqW7Ni40KsQFFtz7rUv1ht+M kihw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-transfer-encoding; bh=xAT2NmAOUeByJ+TmZzvBSZ4oQ+VvE5Og9SzgEmZjzAw=; b=g0rpFe0444jjRty+i6nZSZRAN+zAKYmyozsk79HNGZicUORKU4WbSEYo1gQK0yS2ZU pb1v0FBnIxncBZRSUhd9Y/innMQ2TRQCRzgTHaamvSF9ViZSkIinBIJjUUi/qqNZtVdd CSxFHOJUSjSIoQ62QyU0THugZnQ/ZhYKd+4nLMm1fSjBBfZzyvYyw9c8hB9C4Qwnlf8o 9wcvHeRTLah6dQbcd8eExnGWjUbapuV8qEyPWte07UlKVv6S360dCjXluHUjOlw6/3KN /yJIaloRRQgQsmvTkYyWUV7C8r7fvHx4zBUgB0uapxkMdEYJcARmE51HrWuG51Ezf6M1 VFwA== X-Gm-Message-State: AOAM531kxhDCsWY/UqlthOj3pr1ym1RWVXsSHM4gAj03+YnNQf0yXJeU /bAJn7NZiqF2qxOvDxQVWsbAJ3tdYAaHXQ== X-Google-Smtp-Source: ABdhPJzR0kzyTauT5xthIx85AuM70mAi+r1Hy5aiu/hLz6R/FBHMNaYbaeBhZMl30kZfYQ7AcY9M+Q== X-Received: by 2002:a1c:7416:0:b0:38e:b8b7:e271 with SMTP id p22-20020a1c7416000000b0038eb8b7e271mr29716725wmc.7.1650982587919; Tue, 26 Apr 2022 07:16:27 -0700 (PDT) From: Paolo Bonzini To: qemu-devel@nongnu.org Subject: [PATCH 7/8] qmp: add filtering of statistics by name Date: Tue, 26 Apr 2022 16:16:18 +0200 Message-Id: <20220426141619.304611-8-pbonzini@redhat.com> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220426141619.304611-1-pbonzini@redhat.com> References: <20220426141619.304611-1-pbonzini@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::32c; envelope-from=paolo.bonzini@gmail.com; helo=mail-wm1-x32c.google.com X-Spam_score_int: -14 X-Spam_score: -1.5 X-Spam_bar: - X-Spam_report: (-1.5 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FORGED_FROMDOMAIN=0.249, FREEMAIL_FROM=0.001, HEADER_FROM_DIFFERENT_DOMAINS=0.249, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: berrange@redhat.com, armbru@redhat.com, dgilbert@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZM-MESSAGEID: 1650982722581100003 Content-Type: text/plain; charset="utf-8" Allow retrieving only a subset of statistics. This can be useful for example in order to plot a subset of the statistics many times a second. KVM publishes ~40 statistics for each vCPU on x86; retrieving and serializing all of them would be useless Another use will be in HMP in the following patch; implementing the filter in the backend is easy enough that it was deemed okay to make this a public interface. Example: { "execute": "query-stats", "arguments": { "target": "vcpu", "vcpus": [ "/machine/unattached/device[2]", "/machine/unattached/device[4]" ], "providers": [ { "provider": "kvm", "names": [ "l1d_flush", "exits" ] } } } { "return": { "vcpus": [ { "path": "/machine/unattached/device[2]" "providers": [ { "provider": "kvm", "stats": [ { "name": "l1d_flush", "value": 41213 }, { "name": "exits", "value": 74291 } ] } ] }, { "path": "/machine/unattached/device[4]" "providers": [ { "provider": "kvm", "stats": [ { "name": "l1d_flush", "value": 16132 }, { "name": "exits", "value": 57922 } ] } ] } ] } } Extracted from a patch by Mark Kanda. Signed-off-by: Paolo Bonzini --- accel/kvm/kvm-all.c | 18 +++++++++++------- include/monitor/stats.h | 4 ++-- monitor/qmp-cmds.c | 10 +++++++--- qapi/stats.json | 4 +++- 4 files changed, 23 insertions(+), 13 deletions(-) diff --git a/accel/kvm/kvm-all.c b/accel/kvm/kvm-all.c index b42008ac07..67253c5a5c 100644 --- a/accel/kvm/kvm-all.c +++ b/accel/kvm/kvm-all.c @@ -2311,7 +2311,7 @@ bool kvm_dirty_ring_enabled(void) return kvm_state->kvm_dirty_ring_size ? true : false; } =20 -static void query_stats_cb(StatsResultList **result, StatsTarget target, +static void query_stats_cb(StatsResultList **result, StatsTarget target, s= trList *names, strList *targets, Error **errp); static void query_stats_schemas_cb(StatsSchemaList **result, Error **errp); =20 @@ -3713,6 +3713,7 @@ typedef struct StatsArgs { StatsResultList **stats; StatsSchemaList **schema; } result; + strList *names; Error **errp; } StatsArgs; =20 @@ -3926,7 +3927,7 @@ static StatsDescriptors *find_stats_descriptors(Stats= Target target, int stats_fd return descriptors; } =20 -static void query_stats(StatsResultList **result, StatsTarget target, +static void query_stats(StatsResultList **result, StatsTarget target, strL= ist *names, int stats_fd, Error **errp) { struct kvm_stats_desc *kvm_stats_desc; @@ -3969,6 +3970,9 @@ static void query_stats(StatsResultList **result, Sta= tsTarget target, =20 /* Add entry to the list */ stats =3D (void *)stats_data + pdesc->offset; + if (!str_in_list(pdesc->name, names)) { + continue; + } stats_list =3D add_kvmstat_entry(pdesc, stats, stats_list, errp); } =20 @@ -4030,8 +4034,8 @@ static void query_stats_vcpu(CPUState *cpu, run_on_cp= u_data data) error_propagate(kvm_stats_args->errp, local_err); return; } - query_stats(kvm_stats_args->result.stats, STATS_TARGET_VCPU, stats_fd, - kvm_stats_args->errp); + query_stats(kvm_stats_args->result.stats, STATS_TARGET_VCPU, + kvm_stats_args->names, stats_fd, kvm_stats_args->errp); close(stats_fd); } =20 @@ -4052,7 +4056,7 @@ static void query_stats_schema_vcpu(CPUState *cpu, ru= n_on_cpu_data data) } =20 static void query_stats_cb(StatsResultList **result, StatsTarget target, - strList *targets, Error **errp) + strList *names, strList *targets, Error **errp) { KVMState *s =3D kvm_state; CPUState *cpu; @@ -4066,14 +4070,15 @@ static void query_stats_cb(StatsResultList **result= , StatsTarget target, error_setg(errp, "KVM stats: ioctl failed"); return; } - query_stats(result, target, stats_fd, errp); + query_stats(result, target, names, stats_fd, errp); close(stats_fd); break; } case STATS_TARGET_VCPU: { StatsArgs stats_args; stats_args.result.stats =3D result; + stats_args.names =3D names; stats_args.errp =3D errp; CPU_FOREACH(cpu) { if (!str_in_list(cpu->parent_obj.canonical_path, targets)) { diff --git a/include/monitor/stats.h b/include/monitor/stats.h index acfd975df9..b4123044f7 100644 --- a/include/monitor/stats.h +++ b/include/monitor/stats.h @@ -11,8 +11,8 @@ #include "qapi/qapi-types-stats.h" =20 typedef void StatRetrieveFunc(StatsResultList **result, StatsTarget target, - strList *targets, Error **errp); -typedef void SchemaRetrieveFunc(StatsSchemaList **result, Error **errp); + strList *names, strList *targets, Error **er= rp); +typedef void SchemaRetrieveFunc(StatsSchemaList **, Error **); =20 /* * Register callbacks for the QMP query-stats command. diff --git a/monitor/qmp-cmds.c b/monitor/qmp-cmds.c index 25962d8bb4..d0fdb17c82 100644 --- a/monitor/qmp-cmds.c +++ b/monitor/qmp-cmds.c @@ -468,15 +468,18 @@ static strList *stats_target_filter(StatsFilter *filt= er) } =20 static bool stats_provider_requested(StatsProvider provider, - StatsFilter *filter) + StatsFilter *filter, + strList **p_names) { StatsRequestList *request; =20 if (!filter->has_providers) { + *p_names =3D NULL; return true; } for (request =3D filter->providers; request; request =3D request->next= ) { if (request->value->provider =3D=3D provider) { + *p_names =3D request->value->has_names ? request->value->names= : NULL; return true; } } @@ -490,8 +493,9 @@ StatsResultList *qmp_query_stats(StatsFilter *filter, E= rror **errp) StatsCallbacks *entry; =20 QTAILQ_FOREACH(entry, &stats_callbacks, next) { - if (stats_provider_requested(entry->provider, filter)) { - entry->stats_cb(&stats_results, filter->target, targets, errp); + strList *names =3D NULL; + if (stats_provider_requested(entry->provider, filter, &names)) { + entry->stats_cb(&stats_results, filter->target, names, targets= , errp); } } =20 diff --git a/qapi/stats.json b/qapi/stats.json index 33ff6ea7a9..234fbcb7ca 100644 --- a/qapi/stats.json +++ b/qapi/stats.json @@ -71,11 +71,14 @@ # Indicates a set of statistics that should be returned by query-stats. # # @provider: provider for which to return statistics. + +# @names: statistics to be returned (all if omitted). # # Since: 7.1 ## { 'struct': 'StatsRequest', - 'data': { 'provider': 'StatsProvider' } } + 'data': { 'provider': 'StatsProvider', + '*names': [ 'str' ] } } =20 ## # @StatsVCPUFilter: --=20 2.35.1 From nobody Mon Feb 9 19:55:42 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1650982987555798.0036939742087; Tue, 26 Apr 2022 07:23:07 -0700 (PDT) Received: from localhost ([::1]:57242 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1njM5q-0001Pr-I6 for importer@patchew.org; Tue, 26 Apr 2022 10:23:06 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:38240) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1njLzT-0005WB-Kq for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:35 -0400 Received: from mail-wm1-x335.google.com ([2a00:1450:4864:20::335]:55868) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1njLzR-0005XL-WB for qemu-devel@nongnu.org; Tue, 26 Apr 2022 10:16:31 -0400 Received: by mail-wm1-x335.google.com with SMTP id m62so664388wme.5 for ; Tue, 26 Apr 2022 07:16:29 -0700 (PDT) Received: from avogadro.lan ([2001:b07:6468:f312:e3ec:5559:7c5c:1928]) by smtp.gmail.com with ESMTPSA id o6-20020a05600c378600b0038eca3cdbb3sm11206464wmr.13.2022.04.26.07.16.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 26 Apr 2022 07:16:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=nfdO2sYNKXTeTasqug03s+bRk5Drhel5X5eJOGvauiM=; b=NY9bZ2WUjd5s9m62ic5PCx9UyzV7AM16HuVkvqVvz2BekGi6vpRlpyCyjK1chh2SeO yRkvCG6UkB2BQWw32St2B0lSzUWa/LOTHFaUn1BEnjrKEE5TM3VaegZ6BVVfrgFdPULX Zbr3e0xH1GVjbasIsBbj1Lx3p9NIMduGuR7YFBapIS6gZknPJHyMl2SxwYZesNphRCx9 mB3YyOk6f27Mm6ol5L3yg0Gwvhauvj0oLxr3QDIlCGqMCTg1BJiKOwoRAigYdGA0pXaQ 0SDoNlLqcOczOE/WoHUxGlE5iXR8jBn9ZbMaDw3lkpaHx0u9zkdxRZbBtrMlXLwi1Mxc jwPQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-transfer-encoding; bh=nfdO2sYNKXTeTasqug03s+bRk5Drhel5X5eJOGvauiM=; b=jMqi7rKTucAeLyGgmB/5uHysiHuSY7UoEPtDVNaxyXcvf2ZKbZI0NlKLpD4vlqglSD XtQ9ibbKJobqrk+OkKYb7T1Xzk7dlga7CGGlH37Ztk8qU7vd908lQgqyjOqdj7ljci92 Vb9y0RqJsYnnuGJFqjvcZv8K2sCkqBdt0ndkwI2K+KBJniNuD1ym4CCrDY3hBb52MJQF DVcJWw3qzrWAX03T5SeNln3TM4nMq4atLbE+RAKdyqTwR+LjYXnaprA5m9HLAUW47yY1 KPuZCwnf5cgh87h9BMPUOjdCHOR32/Uqh847r5QsKkV2qx3TXLDiRh++IqBm/i/9c1VG L6Jw== X-Gm-Message-State: AOAM530KgFo9d9f/dBRBGeV46V07odQbrrJETQLc0TeAbyCtM7CwRg1e I8LyGNT2w5WnLY5qk2s6bYeQFX7/KZG6AA== X-Google-Smtp-Source: ABdhPJwKfzG3HmDBBqC+R9OqDJMnOMrPqvQvLODofIPGQMWNbNlqGp5JJbOUp8lRuicQ8K7b85RuZg== X-Received: by 2002:a1c:721a:0:b0:38e:c24d:7b8d with SMTP id n26-20020a1c721a000000b0038ec24d7b8dmr31212207wmc.83.1650982588638; Tue, 26 Apr 2022 07:16:28 -0700 (PDT) From: Paolo Bonzini To: qemu-devel@nongnu.org Subject: [PATCH 8/8] hmp: add filtering of statistics by name Date: Tue, 26 Apr 2022 16:16:19 +0200 Message-Id: <20220426141619.304611-9-pbonzini@redhat.com> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220426141619.304611-1-pbonzini@redhat.com> References: <20220426141619.304611-1-pbonzini@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::335; envelope-from=paolo.bonzini@gmail.com; helo=mail-wm1-x335.google.com X-Spam_score_int: -14 X-Spam_score: -1.5 X-Spam_bar: - X-Spam_report: (-1.5 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FORGED_FROMDOMAIN=0.249, FREEMAIL_FROM=0.001, HEADER_FROM_DIFFERENT_DOMAINS=0.249, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: berrange@redhat.com, armbru@redhat.com, dgilbert@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZM-MESSAGEID: 1650982988648100001 Content-Type: text/plain; charset="utf-8" Allow the user to request only a specific subset of statistics. This can be useful when working on a feature or optimization that is known to affect that statistic. Extracted from a patch by Mark Kanda. Signed-off-by: Paolo Bonzini --- hmp-commands-info.hx | 8 ++++---- monitor/hmp-cmds.c | 35 +++++++++++++++++++++++++---------- 2 files changed, 29 insertions(+), 14 deletions(-) diff --git a/hmp-commands-info.hx b/hmp-commands-info.hx index 1a3e16175f..d533036bc9 100644 --- a/hmp-commands-info.hx +++ b/hmp-commands-info.hx @@ -897,10 +897,10 @@ ERST =20 { .name =3D "stats", - .args_type =3D "target:s,provider:s?", - .params =3D "target [provider]", - .help =3D "show statistics for the given target (vm or vcpu)= ; optionally filter by " - "provider", + .args_type =3D "target:s,names:s?,provider:s?", + .params =3D "target [names] [provider]", + .help =3D "show statistics for the given target (vm or vcpu)= ; optionally filter by" + "name (comma-separated list, or * for all) and provider", .cmd =3D hmp_info_stats, }, =20 diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c index 2bce9d7016..4150d76fd9 100644 --- a/monitor/hmp-cmds.c +++ b/monitor/hmp-cmds.c @@ -2340,10 +2340,12 @@ static void print_stats_results(Monitor *mon, Stats= Target target, } =20 /* Create the StatsFilter that is needed for an "info stats" invocation. = */ -static StatsFilter *stats_filter(StatsTarget target, int cpu_index, - StatsProvider provider) +static StatsFilter *stats_filter(StatsTarget target, const char *names, + int cpu_index, StatsProvider provider) { StatsFilter *filter =3D g_malloc0(sizeof(*filter)); + StatsProvider provider_idx; + StatsRequestList *request_list =3D NULL; =20 filter->target =3D target; switch (target) { @@ -2364,15 +2366,27 @@ static StatsFilter *stats_filter(StatsTarget target= , int cpu_index, break; } =20 - if (provider =3D=3D STATS_PROVIDER__MAX) { + if (!names && provider =3D=3D STATS_PROVIDER__MAX) { return filter; } =20 - /* "info stats" can only query either one or all the providers. */ - StatsRequest *request =3D g_new0(StatsRequest, 1); - request->provider =3D provider; - StatsRequestList *request_list =3D g_new0(StatsRequestList, 1); - QAPI_LIST_PREPEND(request_list, request); + /* + * "info stats" can only query either one or all the providers. Query= ing + * by name, but not by provider, requires the creation of one filter p= er + * provider. + */ + for (provider_idx =3D 0; provider_idx < STATS_PROVIDER__MAX; provider_= idx++) { + if (provider =3D=3D STATS_PROVIDER__MAX || provider =3D=3D provide= r_idx) { + StatsRequest *request =3D g_new0(StatsRequest, 1); + request->provider =3D provider_idx; + if (names && !g_str_equal(names, "*")) { + request->has_names =3D true; + request->names =3D strList_from_comma_list(names); + } + QAPI_LIST_PREPEND(request_list, request); + } + } + filter->has_providers =3D true; filter->providers =3D request_list; return filter; @@ -2382,6 +2396,7 @@ void hmp_info_stats(Monitor *mon, const QDict *qdict) { const char *target_str =3D qdict_get_str(qdict, "target"); const char *provider_str =3D qdict_get_try_str(qdict, "provider"); + const char *names =3D qdict_get_try_str(qdict, "names"); =20 StatsProvider provider =3D STATS_PROVIDER__MAX; StatsTarget target; @@ -2412,11 +2427,11 @@ void hmp_info_stats(Monitor *mon, const QDict *qdic= t) =20 switch (target) { case STATS_TARGET_VM: - filter =3D stats_filter(target, -1, provider); + filter =3D stats_filter(target, names, -1, provider); break; case STATS_TARGET_VCPU: {} int cpu_index =3D monitor_get_cpu_index(mon); - filter =3D stats_filter(target, cpu_index, provider); + filter =3D stats_filter(target, names, cpu_index, provider); break; default: abort(); --=20 2.35.1