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 "expr.h" 10 #include "expr-bison.h" 11 #include "expr-flex.h" 12 #include <linux/kernel.h> 13 #include <linux/zalloc.h> 14 #include <ctype.h> 15 16 #ifdef PARSER_DEBUG 17 extern int expr_debug; 18 #endif 19 20 static size_t key_hash(const void *key, void *ctx __maybe_unused) 21 { 22 const char *str = (const char *)key; 23 size_t hash = 0; 24 25 while (*str != '\0') { 26 hash *= 31; 27 hash += *str; 28 str++; 29 } 30 return hash; 31 } 32 33 static bool key_equal(const void *key1, const void *key2, 34 void *ctx __maybe_unused) 35 { 36 return !strcmp((const char *)key1, (const char *)key2); 37 } 38 39 /* Caller must make sure id is allocated */ 40 int expr__add_id(struct expr_parse_ctx *ctx, const char *id) 41 { 42 struct expr_id_data *data_ptr = NULL, *old_data = NULL; 43 char *old_key = NULL; 44 int ret; 45 46 data_ptr = malloc(sizeof(*data_ptr)); 47 if (!data_ptr) 48 return -ENOMEM; 49 50 data_ptr->parent = ctx->parent; 51 52 ret = hashmap__set(&ctx->ids, id, data_ptr, 53 (const void **)&old_key, (void **)&old_data); 54 if (ret) 55 free(data_ptr); 56 free(old_key); 57 free(old_data); 58 return ret; 59 } 60 61 /* Caller must make sure id is allocated */ 62 int expr__add_id_val(struct expr_parse_ctx *ctx, const char *id, double val) 63 { 64 struct expr_id_data *data_ptr = NULL, *old_data = NULL; 65 char *old_key = NULL; 66 int ret; 67 68 data_ptr = malloc(sizeof(*data_ptr)); 69 if (!data_ptr) 70 return -ENOMEM; 71 data_ptr->val = val; 72 data_ptr->is_ref = false; 73 74 ret = hashmap__set(&ctx->ids, id, data_ptr, 75 (const void **)&old_key, (void **)&old_data); 76 if (ret) 77 free(data_ptr); 78 free(old_key); 79 free(old_data); 80 return ret; 81 } 82 83 int expr__add_ref(struct expr_parse_ctx *ctx, struct metric_ref *ref) 84 { 85 struct expr_id_data *data_ptr = NULL, *old_data = NULL; 86 char *old_key = NULL; 87 char *name, *p; 88 int ret; 89 90 data_ptr = zalloc(sizeof(*data_ptr)); 91 if (!data_ptr) 92 return -ENOMEM; 93 94 name = strdup(ref->metric_name); 95 if (!name) { 96 free(data_ptr); 97 return -ENOMEM; 98 } 99 100 /* 101 * The jevents tool converts all metric expressions 102 * to lowercase, including metric references, hence 103 * we need to add lowercase name for metric, so it's 104 * properly found. 105 */ 106 for (p = name; *p; p++) 107 *p = tolower(*p); 108 109 /* 110 * Intentionally passing just const char pointers, 111 * originally from 'struct pmu_event' object. 112 * We don't need to change them, so there's no 113 * need to create our own copy. 114 */ 115 data_ptr->ref.metric_name = ref->metric_name; 116 data_ptr->ref.metric_expr = ref->metric_expr; 117 data_ptr->ref.counted = false; 118 data_ptr->is_ref = true; 119 120 ret = hashmap__set(&ctx->ids, name, data_ptr, 121 (const void **)&old_key, (void **)&old_data); 122 if (ret) 123 free(data_ptr); 124 125 pr_debug2("adding ref metric %s: %s\n", 126 ref->metric_name, ref->metric_expr); 127 128 free(old_key); 129 free(old_data); 130 return ret; 131 } 132 133 int expr__get_id(struct expr_parse_ctx *ctx, const char *id, 134 struct expr_id_data **data) 135 { 136 return hashmap__find(&ctx->ids, id, (void **)data) ? 0 : -1; 137 } 138 139 int expr__resolve_id(struct expr_parse_ctx *ctx, const char *id, 140 struct expr_id_data **datap) 141 { 142 struct expr_id_data *data; 143 144 if (expr__get_id(ctx, id, datap) || !*datap) { 145 pr_debug("%s not found\n", id); 146 return -1; 147 } 148 149 data = *datap; 150 151 pr_debug2("lookup: is_ref %d, counted %d, val %f: %s\n", 152 data->is_ref, data->ref.counted, data->val, id); 153 154 if (data->is_ref && !data->ref.counted) { 155 data->ref.counted = true; 156 pr_debug("processing metric: %s ENTRY\n", id); 157 if (expr__parse(&data->val, ctx, data->ref.metric_expr, 1)) { 158 pr_debug("%s failed to count\n", id); 159 return -1; 160 } 161 pr_debug("processing metric: %s EXIT: %f\n", id, data->val); 162 } 163 164 return 0; 165 } 166 167 void expr__del_id(struct expr_parse_ctx *ctx, const char *id) 168 { 169 struct expr_id_data *old_val = NULL; 170 char *old_key = NULL; 171 172 hashmap__delete(&ctx->ids, id, 173 (const void **)&old_key, (void **)&old_val); 174 free(old_key); 175 free(old_val); 176 } 177 178 void expr__ctx_init(struct expr_parse_ctx *ctx) 179 { 180 hashmap__init(&ctx->ids, key_hash, key_equal, NULL); 181 } 182 183 void expr__ctx_clear(struct expr_parse_ctx *ctx) 184 { 185 struct hashmap_entry *cur; 186 size_t bkt; 187 188 hashmap__for_each_entry((&ctx->ids), cur, bkt) { 189 free((char *)cur->key); 190 free(cur->value); 191 } 192 hashmap__clear(&ctx->ids); 193 } 194 195 static int 196 __expr__parse(double *val, struct expr_parse_ctx *ctx, const char *expr, 197 int start, int runtime) 198 { 199 struct expr_scanner_ctx scanner_ctx = { 200 .start_token = start, 201 .runtime = runtime, 202 }; 203 YY_BUFFER_STATE buffer; 204 void *scanner; 205 int ret; 206 207 pr_debug2("parsing metric: %s\n", expr); 208 209 ret = expr_lex_init_extra(&scanner_ctx, &scanner); 210 if (ret) 211 return ret; 212 213 buffer = expr__scan_string(expr, scanner); 214 215 #ifdef PARSER_DEBUG 216 expr_debug = 1; 217 expr_set_debug(1, scanner); 218 #endif 219 220 ret = expr_parse(val, ctx, scanner); 221 222 expr__flush_buffer(buffer, scanner); 223 expr__delete_buffer(buffer, scanner); 224 expr_lex_destroy(scanner); 225 return ret; 226 } 227 228 int expr__parse(double *final_val, struct expr_parse_ctx *ctx, 229 const char *expr, int runtime) 230 { 231 return __expr__parse(final_val, ctx, expr, EXPR_PARSE, runtime) ? -1 : 0; 232 } 233 234 int expr__find_other(const char *expr, const char *one, 235 struct expr_parse_ctx *ctx, int runtime) 236 { 237 int ret = __expr__parse(NULL, ctx, expr, EXPR_OTHER, runtime); 238 239 if (one) 240 expr__del_id(ctx, one); 241 242 return ret; 243 } 244