1 // SPDX-License-Identifier: GPL-2.0 2 #include <stdbool.h> 3 #include <assert.h> 4 #include <errno.h> 5 #include <stdlib.h> 6 #include <string.h> 7 #include "metricgroup.h" 8 #include "debug.h" 9 #include "evlist.h" 10 #include "expr.h" 11 #include "smt.h" 12 #include "tool_pmu.h" 13 #include <util/expr-bison.h> 14 #include <util/expr-flex.h> 15 #include "util/hashmap.h" 16 #include "util/header.h" 17 #include "util/pmu.h" 18 #include <perf/cpumap.h> 19 #include <linux/err.h> 20 #include <linux/kernel.h> 21 #include <linux/zalloc.h> 22 #include <ctype.h> 23 #include <math.h> 24 25 struct expr_id_data { 26 union { 27 struct { 28 double val; 29 int source_count; 30 } val; 31 struct { 32 double val; 33 const char *metric_name; 34 const char *metric_expr; 35 } ref; 36 }; 37 38 enum { 39 /* Holding a double value. */ 40 EXPR_ID_DATA__VALUE, 41 /* Reference to another metric. */ 42 EXPR_ID_DATA__REF, 43 /* A reference but the value has been computed. */ 44 EXPR_ID_DATA__REF_VALUE, 45 } kind; 46 }; 47 48 static size_t key_hash(long key, void *ctx __maybe_unused) 49 { 50 const char *str = (const char *)key; 51 size_t hash = 0; 52 53 while (*str != '\0') { 54 hash *= 31; 55 hash += *str; 56 str++; 57 } 58 return hash; 59 } 60 61 static bool key_equal(long key1, long key2, void *ctx __maybe_unused) 62 { 63 return !strcmp((const char *)key1, (const char *)key2); 64 } 65 66 struct hashmap *ids__new(void) 67 { 68 struct hashmap *hash; 69 70 hash = hashmap__new(key_hash, key_equal, NULL); 71 if (IS_ERR(hash)) 72 return NULL; 73 return hash; 74 } 75 76 void ids__free(struct hashmap *ids) 77 { 78 struct hashmap_entry *cur; 79 size_t bkt; 80 81 if (ids == NULL) 82 return; 83 84 hashmap__for_each_entry(ids, cur, bkt) { 85 zfree(&cur->pkey); 86 zfree(&cur->pvalue); 87 } 88 89 hashmap__free(ids); 90 } 91 92 int ids__insert(struct hashmap *ids, const char *id) 93 { 94 struct expr_id_data *data_ptr = NULL, *old_data = NULL; 95 char *old_key = NULL; 96 int ret; 97 98 ret = hashmap__set(ids, id, data_ptr, &old_key, &old_data); 99 if (ret) 100 free(data_ptr); 101 free(old_key); 102 free(old_data); 103 return ret; 104 } 105 106 struct hashmap *ids__union(struct hashmap *ids1, struct hashmap *ids2) 107 { 108 size_t bkt; 109 struct hashmap_entry *cur; 110 int ret; 111 struct expr_id_data *old_data = NULL; 112 char *old_key = NULL; 113 114 if (!ids1) 115 return ids2; 116 117 if (!ids2) 118 return ids1; 119 120 if (hashmap__size(ids1) < hashmap__size(ids2)) { 121 struct hashmap *tmp = ids1; 122 123 ids1 = ids2; 124 ids2 = tmp; 125 } 126 hashmap__for_each_entry(ids2, cur, bkt) { 127 ret = hashmap__set(ids1, cur->key, cur->value, &old_key, &old_data); 128 free(old_key); 129 free(old_data); 130 131 if (ret) { 132 hashmap__free(ids1); 133 hashmap__free(ids2); 134 return NULL; 135 } 136 } 137 hashmap__free(ids2); 138 return ids1; 139 } 140 141 /* Caller must make sure id is allocated */ 142 int expr__add_id(struct expr_parse_ctx *ctx, const char *id) 143 { 144 return ids__insert(ctx->ids, id); 145 } 146 147 /* Caller must make sure id is allocated */ 148 int expr__add_id_val(struct expr_parse_ctx *ctx, const char *id, double val) 149 { 150 return expr__add_id_val_source_count(ctx, id, val, /*source_count=*/1); 151 } 152 153 /* Caller must make sure id is allocated */ 154 int expr__add_id_val_source_count(struct expr_parse_ctx *ctx, const char *id, 155 double val, int source_count) 156 { 157 struct expr_id_data *data_ptr = NULL, *old_data = NULL; 158 char *old_key = NULL; 159 int ret; 160 161 data_ptr = malloc(sizeof(*data_ptr)); 162 if (!data_ptr) 163 return -ENOMEM; 164 data_ptr->val.val = val; 165 data_ptr->val.source_count = source_count; 166 data_ptr->kind = EXPR_ID_DATA__VALUE; 167 168 ret = hashmap__set(ctx->ids, id, data_ptr, &old_key, &old_data); 169 if (ret) 170 free(data_ptr); 171 free(old_key); 172 free(old_data); 173 return ret; 174 } 175 176 int expr__add_ref(struct expr_parse_ctx *ctx, struct metric_ref *ref) 177 { 178 struct expr_id_data *data_ptr = NULL, *old_data = NULL; 179 char *old_key = NULL; 180 char *name; 181 int ret; 182 183 data_ptr = zalloc(sizeof(*data_ptr)); 184 if (!data_ptr) 185 return -ENOMEM; 186 187 name = strdup(ref->metric_name); 188 if (!name) { 189 free(data_ptr); 190 return -ENOMEM; 191 } 192 193 /* 194 * Intentionally passing just const char pointers, 195 * originally from 'struct pmu_event' object. 196 * We don't need to change them, so there's no 197 * need to create our own copy. 198 */ 199 data_ptr->ref.metric_name = ref->metric_name; 200 data_ptr->ref.metric_expr = ref->metric_expr; 201 data_ptr->kind = EXPR_ID_DATA__REF; 202 203 ret = hashmap__set(ctx->ids, name, data_ptr, &old_key, &old_data); 204 if (ret) 205 free(data_ptr); 206 207 pr_debug2("adding ref metric %s: %s\n", 208 ref->metric_name, ref->metric_expr); 209 210 free(old_key); 211 free(old_data); 212 return ret; 213 } 214 215 int expr__get_id(struct expr_parse_ctx *ctx, const char *id, 216 struct expr_id_data **data) 217 { 218 return hashmap__find(ctx->ids, id, data) ? 0 : -1; 219 } 220 221 bool expr__subset_of_ids(struct expr_parse_ctx *haystack, 222 struct expr_parse_ctx *needles) 223 { 224 struct hashmap_entry *cur; 225 size_t bkt; 226 struct expr_id_data *data; 227 228 hashmap__for_each_entry(needles->ids, cur, bkt) { 229 if (expr__get_id(haystack, cur->pkey, &data)) 230 return false; 231 } 232 return true; 233 } 234 235 236 int expr__resolve_id(struct expr_parse_ctx *ctx, const char *id, 237 struct expr_id_data **datap) 238 { 239 struct expr_id_data *data; 240 241 if (expr__get_id(ctx, id, datap) || !*datap) { 242 pr_debug("%s not found\n", id); 243 return -1; 244 } 245 246 data = *datap; 247 248 switch (data->kind) { 249 case EXPR_ID_DATA__VALUE: 250 pr_debug2("lookup(%s): val %f\n", id, data->val.val); 251 break; 252 case EXPR_ID_DATA__REF: 253 pr_debug2("lookup(%s): ref metric name %s\n", id, 254 data->ref.metric_name); 255 pr_debug("processing metric: %s ENTRY\n", id); 256 data->kind = EXPR_ID_DATA__REF_VALUE; 257 if (expr__parse(&data->ref.val, ctx, data->ref.metric_expr)) { 258 pr_debug("%s failed to count\n", id); 259 return -1; 260 } 261 pr_debug("processing metric: %s EXIT: %f\n", id, data->ref.val); 262 break; 263 case EXPR_ID_DATA__REF_VALUE: 264 pr_debug2("lookup(%s): ref val %f metric name %s\n", id, 265 data->ref.val, data->ref.metric_name); 266 break; 267 default: 268 assert(0); /* Unreachable. */ 269 } 270 271 return 0; 272 } 273 274 void expr__del_id(struct expr_parse_ctx *ctx, const char *id) 275 { 276 struct expr_id_data *old_val = NULL; 277 char *old_key = NULL; 278 279 hashmap__delete(ctx->ids, id, &old_key, &old_val); 280 free(old_key); 281 free(old_val); 282 } 283 284 struct expr_parse_ctx *expr__ctx_new(void) 285 { 286 struct expr_parse_ctx *ctx; 287 288 ctx = calloc(1, sizeof(struct expr_parse_ctx)); 289 if (!ctx) 290 return NULL; 291 292 ctx->ids = hashmap__new(key_hash, key_equal, NULL); 293 if (IS_ERR(ctx->ids)) { 294 free(ctx); 295 return NULL; 296 } 297 298 return ctx; 299 } 300 301 void expr__ctx_clear(struct expr_parse_ctx *ctx) 302 { 303 struct hashmap_entry *cur; 304 size_t bkt; 305 306 hashmap__for_each_entry(ctx->ids, cur, bkt) { 307 zfree(&cur->pkey); 308 zfree(&cur->pvalue); 309 } 310 hashmap__clear(ctx->ids); 311 } 312 313 void expr__ctx_free(struct expr_parse_ctx *ctx) 314 { 315 struct hashmap_entry *cur; 316 size_t bkt; 317 318 if (!ctx) 319 return; 320 321 zfree(&ctx->sctx.user_requested_cpu_list); 322 hashmap__for_each_entry(ctx->ids, cur, bkt) { 323 zfree(&cur->pkey); 324 zfree(&cur->pvalue); 325 } 326 hashmap__free(ctx->ids); 327 free(ctx); 328 } 329 330 static int 331 __expr__parse(double *val, struct expr_parse_ctx *ctx, const char *expr, 332 bool compute_ids) 333 { 334 YY_BUFFER_STATE buffer; 335 void *scanner; 336 int ret; 337 338 pr_debug2("parsing metric: %s\n", expr); 339 340 ret = expr_lex_init_extra(&ctx->sctx, &scanner); 341 if (ret) 342 return ret; 343 344 buffer = expr__scan_string(expr, scanner); 345 346 #ifdef PARSER_DEBUG 347 expr_debug = 1; 348 expr_set_debug(1, scanner); 349 #endif 350 351 ret = expr_parse(val, ctx, compute_ids, scanner); 352 353 expr__flush_buffer(buffer, scanner); 354 expr__delete_buffer(buffer, scanner); 355 expr_lex_destroy(scanner); 356 return ret; 357 } 358 359 int expr__parse(double *final_val, struct expr_parse_ctx *ctx, 360 const char *expr) 361 { 362 return __expr__parse(final_val, ctx, expr, /*compute_ids=*/false) ? -1 : 0; 363 } 364 365 int expr__find_ids(const char *expr, const char *one, 366 struct expr_parse_ctx *ctx) 367 { 368 int ret = __expr__parse(NULL, ctx, expr, /*compute_ids=*/true); 369 370 if (one) 371 expr__del_id(ctx, one); 372 373 return ret; 374 } 375 376 double expr_id_data__value(const struct expr_id_data *data) 377 { 378 if (data->kind == EXPR_ID_DATA__VALUE) 379 return data->val.val; 380 assert(data->kind == EXPR_ID_DATA__REF_VALUE); 381 return data->ref.val; 382 } 383 384 double expr_id_data__source_count(const struct expr_id_data *data) 385 { 386 assert(data->kind == EXPR_ID_DATA__VALUE); 387 return data->val.source_count; 388 } 389 390 double expr__get_literal(const char *literal, const struct expr_scanner_ctx *ctx) 391 { 392 double result = NAN; 393 enum tool_pmu_event ev = tool_pmu__str_to_event(literal + 1); 394 395 if (ev != TOOL_PMU__EVENT_NONE) { 396 u64 count; 397 398 if (tool_pmu__read_event(ev, &count)) 399 result = count; 400 else 401 pr_err("Failure to read '%s'", literal); 402 403 } else if (!strcmp("#core_wide", literal)) { 404 result = core_wide(ctx->system_wide, ctx->user_requested_cpu_list) 405 ? 1.0 : 0.0; 406 } else { 407 pr_err("Unrecognized literal '%s'", literal); 408 } 409 410 pr_debug2("literal: %s = %f\n", literal, result); 411 return result; 412 } 413 414 /* Does the event 'id' parse? Determine via ctx->ids if possible. */ 415 double expr__has_event(const struct expr_parse_ctx *ctx, bool compute_ids, const char *id) 416 { 417 struct evlist *tmp; 418 double ret; 419 420 if (hashmap__find(ctx->ids, id, /*value=*/NULL)) 421 return 1.0; 422 423 if (!compute_ids) 424 return 0.0; 425 426 tmp = evlist__new(); 427 if (!tmp) 428 return NAN; 429 430 if (strchr(id, '@')) { 431 char *tmp_id, *p; 432 433 tmp_id = strdup(id); 434 if (!tmp_id) { 435 ret = NAN; 436 goto out; 437 } 438 p = strchr(tmp_id, '@'); 439 *p = '/'; 440 p = strrchr(tmp_id, '@'); 441 *p = '/'; 442 ret = parse_event(tmp, tmp_id) ? 0 : 1; 443 free(tmp_id); 444 } else { 445 ret = parse_event(tmp, id) ? 0 : 1; 446 } 447 out: 448 evlist__delete(tmp); 449 return ret; 450 } 451 452 double expr__strcmp_cpuid_str(const struct expr_parse_ctx *ctx __maybe_unused, 453 bool compute_ids __maybe_unused, const char *test_id) 454 { 455 double ret; 456 struct perf_cpu cpu = {-1}; 457 char *cpuid = get_cpuid_allow_env_override(cpu); 458 459 if (!cpuid) 460 return NAN; 461 462 ret = !strcmp_cpuid_str(test_id, cpuid); 463 464 free(cpuid); 465 return ret; 466 } 467