Markus Armbruster | 6a5fcf6 | 2023-01-24 13:19:37 +0100 | [diff] [blame] | 1 | /* |
| 2 | * HMP commands related to stats |
| 3 | * |
| 4 | * This work is licensed under the terms of the GNU GPL, version 2 or |
| 5 | * (at your option) any later version. |
| 6 | */ |
| 7 | |
| 8 | #include "qemu/osdep.h" |
| 9 | #include "qapi/qapi-commands-stats.h" |
| 10 | #include "monitor/hmp.h" |
| 11 | #include "monitor/monitor.h" |
| 12 | #include "qemu/cutils.h" |
| 13 | #include "hw/core/cpu.h" |
| 14 | #include "qapi/qmp/qdict.h" |
| 15 | #include "qapi/error.h" |
| 16 | |
| 17 | static void print_stats_schema_value(Monitor *mon, StatsSchemaValue *value) |
| 18 | { |
| 19 | const char *unit = NULL; |
| 20 | monitor_printf(mon, " %s (%s%s", value->name, StatsType_str(value->type), |
| 21 | value->has_unit || value->exponent ? ", " : ""); |
| 22 | |
| 23 | if (value->has_unit) { |
| 24 | if (value->unit == STATS_UNIT_SECONDS) { |
| 25 | unit = "s"; |
| 26 | } else if (value->unit == STATS_UNIT_BYTES) { |
| 27 | unit = "B"; |
| 28 | } |
| 29 | } |
| 30 | |
| 31 | if (unit && value->base == 10 && |
| 32 | value->exponent >= -18 && value->exponent <= 18 && |
| 33 | value->exponent % 3 == 0) { |
| 34 | monitor_puts(mon, si_prefix(value->exponent)); |
| 35 | } else if (unit && value->base == 2 && |
| 36 | value->exponent >= 0 && value->exponent <= 60 && |
| 37 | value->exponent % 10 == 0) { |
| 38 | |
| 39 | monitor_puts(mon, iec_binary_prefix(value->exponent)); |
| 40 | } else if (value->exponent) { |
| 41 | /* Use exponential notation and write the unit's English name */ |
| 42 | monitor_printf(mon, "* %d^%d%s", |
| 43 | value->base, value->exponent, |
| 44 | value->has_unit ? " " : ""); |
| 45 | unit = NULL; |
| 46 | } |
| 47 | |
| 48 | if (value->has_unit) { |
| 49 | monitor_puts(mon, unit ? unit : StatsUnit_str(value->unit)); |
| 50 | } |
| 51 | |
| 52 | /* Print bucket size for linear histograms */ |
| 53 | if (value->type == STATS_TYPE_LINEAR_HISTOGRAM && value->has_bucket_size) { |
| 54 | monitor_printf(mon, ", bucket size=%d", value->bucket_size); |
| 55 | } |
| 56 | monitor_printf(mon, ")"); |
| 57 | } |
| 58 | |
| 59 | static StatsSchemaValueList *find_schema_value_list( |
| 60 | StatsSchemaList *list, StatsProvider provider, |
| 61 | StatsTarget target) |
| 62 | { |
| 63 | StatsSchemaList *node; |
| 64 | |
| 65 | for (node = list; node; node = node->next) { |
| 66 | if (node->value->provider == provider && |
| 67 | node->value->target == target) { |
| 68 | return node->value->stats; |
| 69 | } |
| 70 | } |
| 71 | return NULL; |
| 72 | } |
| 73 | |
| 74 | static void print_stats_results(Monitor *mon, StatsTarget target, |
| 75 | bool show_provider, |
| 76 | StatsResult *result, |
| 77 | StatsSchemaList *schema) |
| 78 | { |
| 79 | /* Find provider schema */ |
| 80 | StatsSchemaValueList *schema_value_list = |
| 81 | find_schema_value_list(schema, result->provider, target); |
| 82 | StatsList *stats_list; |
| 83 | |
| 84 | if (!schema_value_list) { |
| 85 | monitor_printf(mon, "failed to find schema list for %s\n", |
| 86 | StatsProvider_str(result->provider)); |
| 87 | return; |
| 88 | } |
| 89 | |
| 90 | if (show_provider) { |
| 91 | monitor_printf(mon, "provider: %s\n", |
| 92 | StatsProvider_str(result->provider)); |
| 93 | } |
| 94 | |
| 95 | for (stats_list = result->stats; stats_list; |
| 96 | stats_list = stats_list->next, |
| 97 | schema_value_list = schema_value_list->next) { |
| 98 | |
| 99 | Stats *stats = stats_list->value; |
| 100 | StatsValue *stats_value = stats->value; |
| 101 | StatsSchemaValue *schema_value = schema_value_list->value; |
| 102 | |
| 103 | /* Find schema entry */ |
| 104 | while (!g_str_equal(stats->name, schema_value->name)) { |
| 105 | if (!schema_value_list->next) { |
| 106 | monitor_printf(mon, "failed to find schema entry for %s\n", |
| 107 | stats->name); |
| 108 | return; |
| 109 | } |
| 110 | schema_value_list = schema_value_list->next; |
| 111 | schema_value = schema_value_list->value; |
| 112 | } |
| 113 | |
| 114 | print_stats_schema_value(mon, schema_value); |
| 115 | |
| 116 | if (stats_value->type == QTYPE_QNUM) { |
| 117 | monitor_printf(mon, ": %" PRId64 "\n", stats_value->u.scalar); |
| 118 | } else if (stats_value->type == QTYPE_QBOOL) { |
| 119 | monitor_printf(mon, ": %s\n", stats_value->u.boolean ? "yes" : "no"); |
| 120 | } else if (stats_value->type == QTYPE_QLIST) { |
| 121 | uint64List *list; |
| 122 | int i; |
| 123 | |
| 124 | monitor_printf(mon, ": "); |
| 125 | for (list = stats_value->u.list, i = 1; |
| 126 | list; |
| 127 | list = list->next, i++) { |
| 128 | monitor_printf(mon, "[%d]=%" PRId64 " ", i, list->value); |
| 129 | } |
| 130 | monitor_printf(mon, "\n"); |
| 131 | } |
| 132 | } |
| 133 | } |
| 134 | |
| 135 | /* Create the StatsFilter that is needed for an "info stats" invocation. */ |
| 136 | static StatsFilter *stats_filter(StatsTarget target, const char *names, |
| 137 | int cpu_index, StatsProvider provider) |
| 138 | { |
| 139 | StatsFilter *filter = g_malloc0(sizeof(*filter)); |
| 140 | StatsProvider provider_idx; |
| 141 | StatsRequestList *request_list = NULL; |
| 142 | |
| 143 | filter->target = target; |
| 144 | switch (target) { |
| 145 | case STATS_TARGET_VM: |
| 146 | break; |
| 147 | case STATS_TARGET_VCPU: |
| 148 | { |
| 149 | strList *vcpu_list = NULL; |
| 150 | CPUState *cpu = qemu_get_cpu(cpu_index); |
| 151 | char *canonical_path = object_get_canonical_path(OBJECT(cpu)); |
| 152 | |
| 153 | QAPI_LIST_PREPEND(vcpu_list, canonical_path); |
| 154 | filter->u.vcpu.has_vcpus = true; |
| 155 | filter->u.vcpu.vcpus = vcpu_list; |
| 156 | break; |
| 157 | } |
zhenwei pi | f2b9010 | 2023-03-01 18:58:46 +0800 | [diff] [blame] | 158 | case STATS_TARGET_CRYPTODEV: |
| 159 | break; |
Markus Armbruster | 6a5fcf6 | 2023-01-24 13:19:37 +0100 | [diff] [blame] | 160 | default: |
| 161 | break; |
| 162 | } |
| 163 | |
| 164 | if (!names && provider == STATS_PROVIDER__MAX) { |
| 165 | return filter; |
| 166 | } |
| 167 | |
| 168 | /* |
| 169 | * "info stats" can only query either one or all the providers. Querying |
| 170 | * by name, but not by provider, requires the creation of one filter per |
| 171 | * provider. |
| 172 | */ |
| 173 | for (provider_idx = 0; provider_idx < STATS_PROVIDER__MAX; provider_idx++) { |
| 174 | if (provider == STATS_PROVIDER__MAX || provider == provider_idx) { |
| 175 | StatsRequest *request = g_new0(StatsRequest, 1); |
| 176 | request->provider = provider_idx; |
| 177 | if (names && !g_str_equal(names, "*")) { |
| 178 | request->has_names = true; |
| 179 | request->names = hmp_split_at_comma(names); |
| 180 | } |
| 181 | QAPI_LIST_PREPEND(request_list, request); |
| 182 | } |
| 183 | } |
| 184 | |
| 185 | filter->has_providers = true; |
| 186 | filter->providers = request_list; |
| 187 | return filter; |
| 188 | } |
| 189 | |
| 190 | void hmp_info_stats(Monitor *mon, const QDict *qdict) |
| 191 | { |
| 192 | const char *target_str = qdict_get_str(qdict, "target"); |
| 193 | const char *provider_str = qdict_get_try_str(qdict, "provider"); |
| 194 | const char *names = qdict_get_try_str(qdict, "names"); |
| 195 | |
| 196 | StatsProvider provider = STATS_PROVIDER__MAX; |
| 197 | StatsTarget target; |
| 198 | Error *err = NULL; |
| 199 | g_autoptr(StatsSchemaList) schema = NULL; |
| 200 | g_autoptr(StatsResultList) stats = NULL; |
| 201 | g_autoptr(StatsFilter) filter = NULL; |
| 202 | StatsResultList *entry; |
| 203 | |
| 204 | target = qapi_enum_parse(&StatsTarget_lookup, target_str, -1, &err); |
| 205 | if (err) { |
| 206 | monitor_printf(mon, "invalid stats target %s\n", target_str); |
| 207 | goto exit_no_print; |
| 208 | } |
| 209 | if (provider_str) { |
| 210 | provider = qapi_enum_parse(&StatsProvider_lookup, provider_str, -1, &err); |
| 211 | if (err) { |
| 212 | monitor_printf(mon, "invalid stats provider %s\n", provider_str); |
| 213 | goto exit_no_print; |
| 214 | } |
| 215 | } |
| 216 | |
| 217 | schema = qmp_query_stats_schemas(provider_str ? true : false, |
| 218 | provider, &err); |
| 219 | if (err) { |
| 220 | goto exit; |
| 221 | } |
| 222 | |
| 223 | switch (target) { |
| 224 | case STATS_TARGET_VM: |
| 225 | filter = stats_filter(target, names, -1, provider); |
| 226 | break; |
| 227 | case STATS_TARGET_VCPU: {} |
| 228 | int cpu_index = monitor_get_cpu_index(mon); |
| 229 | filter = stats_filter(target, names, cpu_index, provider); |
| 230 | break; |
zhenwei pi | f2b9010 | 2023-03-01 18:58:46 +0800 | [diff] [blame] | 231 | case STATS_TARGET_CRYPTODEV: |
| 232 | filter = stats_filter(target, names, -1, provider); |
| 233 | break; |
Markus Armbruster | 6a5fcf6 | 2023-01-24 13:19:37 +0100 | [diff] [blame] | 234 | default: |
| 235 | abort(); |
| 236 | } |
| 237 | |
| 238 | stats = qmp_query_stats(filter, &err); |
| 239 | if (err) { |
| 240 | goto exit; |
| 241 | } |
| 242 | for (entry = stats; entry; entry = entry->next) { |
| 243 | print_stats_results(mon, target, provider_str == NULL, entry->value, schema); |
| 244 | } |
| 245 | |
| 246 | exit: |
| 247 | if (err) { |
| 248 | monitor_printf(mon, "%s\n", error_get_pretty(err)); |
| 249 | } |
| 250 | exit_no_print: |
| 251 | error_free(err); |
| 252 | } |