[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[PATCH v4 2/3] hmp: Support for querying stats
|
From: |
Mark Kanda |
|
Subject: |
[PATCH v4 2/3] hmp: Support for querying stats |
|
Date: |
Tue, 15 Feb 2022 09:04:32 -0600 |
Leverage the QMP support for querying stats. The interface supports similar
arguments as the QMP interface. Wildcard char (*) is accepted for names and
stats target.
Examples (with fd-based KVM stats):
- Display all stats
(qemu) info stats
vm
provider: kvm
max_mmu_page_hash_collisions (peak): 0
max_mmu_rmap_size (peak): 0
...
vcpu (qom path: /machine/unattached/device[0])
provider: kvm
guest_mode (instant): 0
directed_yield_successful (cumulative): 0
...
(qemu) info stats-schemas
vm
provider: kvm
max_mmu_page_hash_collisions (peak)
max_mmu_rmap_size (peak)
...
vcpu
provider: kvm
guest_mode (instant)
directed_yield_successful (cumulative)
- Display 'halt_wait_ns' and 'exits' for vCPUs with qom paths
/machine/unattached/device[2] and /machine/unattached/device[4]:
(qemu) info stats exits,halt_wait_ns /machine/unattached/device[2],
/machine/unattached/device[4]
vcpu (qom path: /machine/unattached/device[2])
provider: kvm
exits (cumulative): 52369
halt_wait_ns (cumulative nanoseconds): 416092704390
vcpu (qom path: /machine/unattached/device[4])
provider: kvm
exits (cumulative): 52550
halt_wait_ns (cumulative nanoseconds): 419637402657
- Display all VM stats for provider KVM:
(qemu) info stats * vm kvm
vm
provider: kvm
max_mmu_page_hash_collisions (peak): 0
max_mmu_rmap_size (peak): 0
nx_lpage_splits (instant): 51
...
Signed-off-by: Mark Kanda <mark.kanda@oracle.com>
---
hmp-commands-info.hx | 28 ++++
include/monitor/hmp.h | 2 +
monitor/hmp-cmds.c | 328 ++++++++++++++++++++++++++++++++++++++++++
3 files changed, 358 insertions(+)
diff --git a/hmp-commands-info.hx b/hmp-commands-info.hx
index e90f20a107..c0ad3a3e2a 100644
--- a/hmp-commands-info.hx
+++ b/hmp-commands-info.hx
@@ -879,3 +879,31 @@ SRST
``info sgx``
Show intel SGX information.
ERST
+
+ {
+ .name = "stats",
+ .args_type = "names:s?,vcpus:s?,provider:s?",
+ .params = "[names] [vcpus] [provider]",
+ .help = "show statistics; optional comma separated names, "
+ "vcpu qom paths, and provider",
+ .cmd = hmp_info_stats,
+ },
+
+SRST
+ ``stats``
+ Show stats
+ERST
+
+ {
+ .name = "stats-schemas",
+ .args_type = "provider:s?",
+ .params = "[provider]",
+ .help = "show statistics schema for each provider",
+ .cmd = hmp_info_stats_schemas,
+ },
+
+SRST
+ ``stats-schemas``
+ Show stats per schema
+ERST
+
diff --git a/include/monitor/hmp.h b/include/monitor/hmp.h
index 96d014826a..a748511105 100644
--- a/include/monitor/hmp.h
+++ b/include/monitor/hmp.h
@@ -133,5 +133,7 @@ void hmp_info_dirty_rate(Monitor *mon, const QDict *qdict);
void hmp_calc_dirty_rate(Monitor *mon, const QDict *qdict);
void hmp_human_readable_text_helper(Monitor *mon,
HumanReadableText *(*qmp_handler)(Error
**));
+void hmp_info_stats(Monitor *mon, const QDict *qdict);
+void hmp_info_stats_schemas(Monitor *mon, const QDict *qdict);
#endif
diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c
index 8c384dc1b2..2a8f1432fb 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"
@@ -2178,3 +2179,330 @@ void hmp_info_memory_size_summary(Monitor *mon, const
QDict *qdict)
}
hmp_handle_error(mon, err);
}
+
+static void print_stats_schema_value(Monitor *mon, StatsSchemaValue *value)
+{
+ monitor_printf(mon, " %s (%s", value->name, StatsType_str(value->type));
+
+ if (value->unit == STATS_UNIT_SECONDS &&
+ value->exponent >= -9 && value->exponent <= 0 &&
+ value->exponent % 3 == 0 && value->base == STATS_BASE_POW10) {
+
+ const char *si_prefix[] = { "", "milli", "micro", "nano" };
+ monitor_printf(mon, " %s", si_prefix[value->exponent / -3]);
+
+ } else if (value->unit == STATS_UNIT_BYTES &&
+ value->exponent >= 0 && value->exponent <= 40 &&
+ value->exponent % 10 == 0 && value->base == STATS_BASE_POW2) {
+
+ const char *si_prefix[] = {
+ "", "kilo", "mega", "giga", "tera" };
+ monitor_printf(mon, " %s", si_prefix[value->exponent / 10]);
+
+ } else if (value->exponent) {
+ /* Print the base and exponent as "x <base>^<exp>" */
+ monitor_printf(mon, " x %s^%d", StatsBase_str(value->base),
+ value->exponent);
+ }
+
+ /* Don't print "none" unit type */
+ monitor_printf(mon, "%s)", value->unit == STATS_UNIT_NONE ?
+ "" : StatsUnit_str(value->unit));
+
+ /* Print bucket size for linear histograms */
+ if ((value->type == STATS_TYPE_LINEAR_HIST) && value->has_bucket_size) {
+ monitor_printf(mon, " bucket-size=%d", value->bucket_size);
+ }
+}
+
+static StatsSchemaValueList *find_schema_value_list(
+ StatsSchemaProviderList *list, StatsProvider provider)
+{
+ StatsSchemaProviderList *schema_provider_list;
+
+ for (schema_provider_list = list;
+ schema_provider_list;
+ schema_provider_list = schema_provider_list->next) {
+ if (schema_provider_list->value->provider == provider) {
+ return schema_provider_list->value->stats;
+ }
+ }
+ return NULL;
+}
+
+static void print_stats_results(Monitor *mon, StatsTarget type,
+ StatsResultsEntryList *list,
+ StatsSchemaProviderList *schema)
+{
+ StatsResultsEntryList *results_entry_list;
+
+ for (results_entry_list = list;
+ results_entry_list;
+ results_entry_list = results_entry_list->next) {
+
+ StatsResultsEntry *results_entry = results_entry_list->value;
+ /* Find provider schema */
+ StatsSchemaValueList *schema_value_list =
+ find_schema_value_list(schema, results_entry->provider);
+ StatsList *stats_list;
+
+ if (!schema_value_list) {
+ monitor_printf(mon, "failed to find schema list for %s\n",
+ StatsProvider_str(results_entry->provider));
+ return;
+ }
+
+ monitor_printf(mon, " provider: %s\n",
+ StatsProvider_str(results_entry->provider));
+
+ for (stats_list = results_entry->stats;
+ stats_list;
+ stats_list = stats_list->next,
+ schema_value_list = schema_value_list->next) {
+
+ Stats *stats = stats_list->value;
+ StatsValue *stats_value = stats->value;
+ StatsSchemaValue *schema_value = 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 = schema_value_list->next;
+ schema_value = schema_value_list->value;
+ }
+
+ print_stats_schema_value(mon, schema_value);
+
+ if (stats_value->type == QTYPE_QNUM) {
+ monitor_printf(mon, ": %" PRId64 "\n", stats_value->u.scalar);
+ } else if (stats_value->type == QTYPE_QDICT) {
+ uint64List *list;
+ int i;
+
+ monitor_printf(mon, ": ");
+ for (list = stats_value->u.list.values, i = 1;
+ list;
+ list = list->next, i++) {
+ monitor_printf(mon, "[%d]=%" PRId64 " ", i, list->value);
+ }
+ monitor_printf(mon, "\n");
+ }
+ }
+ }
+}
+
+static const char wildcard[] = "*";
+static StatsFilter *stats_filter(StatsTarget target, const char *names,
+ const char *vcpus, StatsProvider provider)
+{
+ StatsFilter *filter = g_malloc0(sizeof(*filter));
+ filter->target = target;
+
+ switch (target) {
+ case STATS_TARGET_VM:
+ {
+ StatsRequestList *request_list = NULL;
+ StatsRequest *request = g_malloc0(sizeof(*request));
+
+ if (names && !g_str_equal(names, wildcard)) {
+ request->fields = strList_from_comma_list(names);
+ request->has_fields = true;
+ }
+ if (provider != STATS_PROVIDER__MAX) {
+ request->provider = provider;
+ request->has_provider = true;
+ }
+
+ QAPI_LIST_PREPEND(request_list, request);
+ filter->u.vm.filters = request_list;
+ filter->u.vm.has_filters = true;
+ break;
+ }
+ case STATS_TARGET_VCPU:
+ {
+ StatsRequestList *request_list = NULL;
+ StatsRequest *request = g_malloc0(sizeof(*request));
+ if (names && !g_str_equal(names, wildcard)) {
+ request->fields = strList_from_comma_list(names);
+ request->has_fields = true;
+ }
+ if (provider != STATS_PROVIDER__MAX) {
+ request->provider = provider;
+ request->has_provider = true;
+ }
+
+ if (vcpus && !g_str_equal(vcpus, wildcard) &&
+ !g_str_equal(vcpus, StatsTarget_str(STATS_TARGET_VCPU))) {
+ filter->u.vcpu.vcpus = strList_from_comma_list(vcpus);
+ filter->u.vcpu.has_vcpus = true;
+ }
+
+ QAPI_LIST_PREPEND(request_list, request);
+ filter->u.vcpu.filters = request_list;
+ filter->u.vcpu.has_filters = true;
+ break;
+ }
+ default:
+ break;
+ }
+ return filter;
+}
+
+void hmp_info_stats(Monitor *mon, const QDict *qdict)
+{
+ const char *names = qdict_get_try_str(qdict, "names");
+ const char *vcpus = qdict_get_try_str(qdict, "vcpus");
+ const char *provider = qdict_get_try_str(qdict, "provider");
+
+ StatsProvider stats_provider = STATS_PROVIDER__MAX;
+ StatsTarget target;
+ Error *err = NULL;
+
+ if (provider) {
+ for (stats_provider = 0; stats_provider < STATS_PROVIDER__MAX;
+ stats_provider++) {
+ if (g_str_equal(StatsProvider_str(stats_provider), provider)) {
+ break;
+ }
+ }
+ if (stats_provider == STATS_PROVIDER__MAX) {
+ monitor_printf(mon, "invalid stats filter provider %s\n",
+ provider);
+ goto exit;
+ }
+ }
+
+ for (target = 0; target < STATS_TARGET__MAX; target++) {
+ StatsResults *stats_results = NULL;
+ StatsSchemaResults *schema_results = NULL;
+ StatsResultsVCPUEntryList *results_entry_list;
+
+ StatsFilter *filter = stats_filter(target, names, vcpus,
+ stats_provider);
+ switch (target) {
+ case STATS_TARGET_VM:
+ if (vcpus && !g_str_equal(vcpus, wildcard) &&
+ !g_str_equal(vcpus, StatsTarget_str(STATS_TARGET_VM))) {
+ break;
+ }
+ stats_results = qmp_query_stats(filter, &err);
+ if (err) {
+ goto exit;
+ }
+ schema_results =
+ qmp_query_stats_schemas(provider ? true : false,
+ stats_provider, &err);
+ if (err) {
+ goto exit;
+ }
+ if (!stats_results->has_vm) {
+ break;
+ }
+ monitor_printf(mon, "%s\n", StatsTarget_str(STATS_TARGET_VM));
+ print_stats_results(mon, STATS_TARGET_VM, stats_results->vm,
+ schema_results->vm);
+
+ break;
+ case STATS_TARGET_VCPU:
+ stats_results = qmp_query_stats(filter, &err);
+ if (err) {
+ goto exit;
+ }
+ schema_results =
+ qmp_query_stats_schemas(provider ? true : false,
+ stats_provider, &err);
+ if (err) {
+ goto exit;
+ }
+ for (results_entry_list = stats_results->vcpus;
+ results_entry_list;
+ results_entry_list = results_entry_list->next) {
+ monitor_printf(mon, "%s (qom path: %s)\n",
+ StatsTarget_str(STATS_TARGET_VCPU),
+ results_entry_list->value->path);
+
+ print_stats_results(mon, STATS_TARGET_VCPU,
+ results_entry_list->value->providers,
+ schema_results->vcpu);
+ }
+ break;
+ default:
+ break;
+ }
+ qapi_free_StatsFilter(filter);
+ qapi_free_StatsSchemaResults(schema_results);
+ qapi_free_StatsResults(stats_results);
+ }
+
+exit:
+ if (err) {
+ monitor_printf(mon, "%s\n", error_get_pretty(err));
+ error_free(err);
+ }
+}
+
+static void print_stats_schema_list(Monitor *mon, StatsSchemaProviderList
*list)
+{
+ StatsSchemaProviderList *schema_provider_list;
+
+ for (schema_provider_list = list;
+ schema_provider_list;
+ schema_provider_list = schema_provider_list->next) {
+
+ StatsSchemaProvider *schema_provider =
+ schema_provider_list->value;
+ monitor_printf(mon, " provider: %s\n",
+ StatsProvider_str(schema_provider->provider));
+
+ StatsSchemaValueList *schema_value_list;
+ for (schema_value_list = schema_provider->stats;
+ schema_value_list;
+ schema_value_list = schema_value_list->next) {
+
+ StatsSchemaValue *schema_value = schema_value_list->value;
+ print_stats_schema_value(mon, schema_value);
+ monitor_printf(mon, "\n");
+ }
+ }
+}
+
+void hmp_info_stats_schemas(Monitor *mon, const QDict *qdict)
+{
+ const char *provider = qdict_get_try_str(qdict, "provider");
+ StatsProvider stats_provider = STATS_PROVIDER__MAX;
+ StatsSchemaResults *schema_result;
+ Error *err = NULL;
+
+ if (provider) {
+ for (stats_provider = 0; stats_provider < STATS_PROVIDER__MAX;
+ stats_provider++) {
+ if (g_str_equal(StatsProvider_str(stats_provider), provider)) {
+ break;
+ }
+ }
+ if (stats_provider == STATS_PROVIDER__MAX) {
+ monitor_printf(mon, "invalid stats filter provider %s\n",
provider);
+ return;
+ }
+ }
+
+ schema_result =
+ qmp_query_stats_schemas(provider ? true : false, stats_provider, &err);
+
+ if (err) {
+ monitor_printf(mon, "%s\n", error_get_pretty(err));
+ error_free(err);
+ return;
+ }
+
+ monitor_printf(mon, "%s\n", StatsTarget_str(STATS_TARGET_VM));
+ print_stats_schema_list(mon, schema_result->vm);
+ monitor_printf(mon, "%s\n", StatsTarget_str(STATS_TARGET_VCPU));
+ print_stats_schema_list(mon, schema_result->vcpu);
+
+ qapi_free_StatsSchemaResults(schema_result);
+}
--
2.27.0