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